五、JDBC教程+案例学习笔记

JDBC的基本概念

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

JDBC快速入门

* 步骤：
	1、导入驱动jar包
		* 在项目目录下新建libs文件夹，下载mysql-connector-java的jar包
		* 将libs目录添加为项目的library   右键-->Add as Library
	2、注册驱动
	3、获取数据库连接对象COnnection
	4、定义sql
	5、获取执行sql语句的对象 Statement
	6、执行sql，接受返回结果
	7、处理结果
	8、释放资源

• 代码实现

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

/**
 * JDBC快速入门
 */
public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {
        //1、导入驱动jar包
        // 2、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 3、获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/数据库", "账户", "密码");
        //4、定义sql语句
        String sql = "UPDATE account SET balance=1000 where `id`=3";
        //5、获取执行sql对象 Statement
        Statement stmt = conn.createStatement();
        
        //6、执行sql
        int count = stmt.executeUpdate(sql);
        // 7、处理结果
        System.out.println(count);
        // 8、释放资源
        stmt.close();
        conn.close();

    }
}

JDBC接口和类详解

1、DriverManager：驱动管理对象
	* 功能：
		* 1、注册驱动
			static void	registerDriver(Driver driver) 注册与给定的驱动程序 DriverManager 。
			写代码使用： 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!");
			        }
				}

			注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
		* 2、获取数据库连接	
			方法：getConnection(String url, String user, String password) 尝试建立与给定数据库URL的连接。
			参数：
				* url：指定连接的路径
					* 语法： jdbc：mysql//ip地址（域名）:端口号/数据库名称
					* 例子：jdbc:mysql//localhost:3306/db3
				* user：用户名
				* password： 密码
2、Connection: 数据库连接对象
	* 功能：
		1. 获取执行sql 的对象
			* Statement createStatement()
			* PreparedStatement prepareStatement(String sql)  
		2. 管理事务：
			* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
			* 提交事务：commit() 
			* 回滚事务：rollback() 
3、Statement：执行sql对象
	1. 执行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)语句
	2. 练习：
		1. account表 添加一条记录
		2. account表 修改记录
		3. account表 删除一条记录

package cn.study.jdbc;

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

/**
 * Created by yanyuchun on 2020/7/23
 */
public class JdbcDemo2 {
    public static void main(String[] args) throws Exception {
        // 1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2、获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
        // 3、获取执行sql对象
        Statement stmt = conn.createStatement();
        // 4、定义sql语句
        String sql1= "INSERT INTO account ( NAME, balance )\n" +
                "VALUES\n" +
                "\t( 'kevin', 9999 ),\n" +
                "\t( 'mars', 100000 )";
        String sql2="UPDATE account SET balance = balance-3000 WHERE `name`='kevin'";
        String sql3="DELETE FROM account WHERE id=4";

        // 5、执行sql语句
        System.out.println(stmt.executeUpdate(sql1));
        System.out.println(stmt.executeUpdate(sql2));
        System.out.println(stmt.executeUpdate(sql3));

        // 6、关闭连接
        stmt.close();
        conn.close();



    }
}

4、ResultSet：结果集对象，封装查询结果
	* boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
	* getXxx(参数):获取数据
		* Xxx：代表数据类型   如： int getInt() ,	String getString()
		* 参数：
			1. int：代表列的编号,从1开始   如： getString(1)
			2. String：代表列名称。 如： getDouble("balance")
	* 注意：
		* 使用步骤：
			1. 游标向下移动一行
			2. 判断是否有数据
			3. 获取数据
		   //循环判断游标是否是最后一行末尾。
	* 练习：
		* 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
			1. 定义Emp类
			2. 定义方法 public List<Emp> findAll(){}
			3. 实现方法 select * from emp;

package cn.study.jdbc.domain;

import java.util.Date;

/**
 * Emp类
 */
public class Emp {
    private int id;
    private String eName;
    private  int job_id;
    private  int mgr;

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", eName='" + eName + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joinDate=" + joinDate +
                ", salary=" + salary +
                ", bonds=" + bonds +
                ", dept_id=" + dept_id +
                '}';
    }

    private Date joinDate;
    private double salary;
    private double bonds;
    private int dept_id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String geteName() {
        return eName;
    }

    public void seteName(String eName) {
        this.eName = eName;
    }

    public int getJob_id() {
        return job_id;
    }

    public void setJob_id(int job_id) {
        this.job_id = job_id;
    }

    public int getMgr() {
        return mgr;
    }

    public void setMgr(int mgr) {
        this.mgr = mgr;
    }

    public Date getJoinDate() {
        return joinDate;
    }

    public void setJoinDate(Date joinDate) {
        this.joinDate = joinDate;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonds() {
        return bonds;
    }

    public void setBonds(double bonds) {
        this.bonds = bonds;
    }

    public int getDept_id() {
        return dept_id;
    }

    public void setDept_id(int dept_id) {
        this.dept_id = dept_id;
    }




}

package cn.study.jdbc.domain;

import com.sun.org.apache.bcel.internal.generic.IFNULL;
import jdk.nashorn.internal.parser.JSONParser;

import java.sql.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 执行
 */
public class JdbcDemo8 {
    /**
     * 查询所有emp对象
     *
     * @return
     */
    public List<Emp> findAll() {
        String host="jdbc:mysql:///db3";
        String user="root";
        String pwd = "password";
        List<Emp> result = new ArrayList<>();
        Connection conn = null;
        Statement stmt = null;
        ResultSet resultSet = null;
        try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2、获取连接
            try {
                conn = DriverManager.getConnection(host, user, pwd);
                stmt = conn.createStatement();
                //3、创建sql语句
                String sql="select  * from emp";
                resultSet = stmt.executeQuery(sql);
                // 4、如果查询到有数据，进行处理
                while (resultSet.next()){
                    Emp emp =new Emp();
                    emp.setId(resultSet.getInt(1));
                    emp.seteName(resultSet.getString(2));
                    emp.setJob_id(resultSet.getInt(3));
                    emp.setMgr(resultSet.getInt(4));
                    emp.setJoinDate(resultSet.getDate(5));
                    emp.setSalary(resultSet.getDouble(6));
                    emp.setBonds(resultSet.getDouble(7));
                    emp.setDept_id(resultSet.getInt(8));

                    result.add(emp);
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {{
            // 6、关闭连接
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        }
        return result;
    }
    public static void main(String[] args) {
        List<Emp> all = new JdbcDemo8().findAll();
        System.out.println(all);
        System.out.println(all.size());
    }
}

5、PreParedStatement：执行sql的对象
	1、sql注入问题：在拼接sql时有一些sql的特殊关键字参与字符串的拼接，会造成安全性问题
	2、解决sql注入问题：使用PreParedStatement对象来解决
	3、预编译的SQL：参数使用？作为占位符
	4、步骤：
			1、导入驱动jar包
				* 在项目目录下新建libs文件夹，下载mysql-connector-java的jar包
				* 将libs目录添加为项目的library   右键-->Add as Library
			2、注册驱动
			3、获取数据库连接对象COnnection
			4、定义sql
				* 主要 ：sql的参数使用？作为占位符。
				* 如 select	* from user where username = ? and password = ?;
			5、获取执行sql语句的对象 PreParedStatement   Connection.PreParedStatement(String sql);
			6 、给？赋值
				* 方法 ：setXxx（参数1 ，参数2）
					* 参数1 ：？的位置，编号从1 开始
					* 参数2 ：？的值
			6、执行sql，接受返回结果
			7、处理结果
			8、释放资源
	5、注意：后期都会使用PreparedStatement来完成增删改查的所有操作
		* 可以防止sql注入
		* 效率更高

抽取JDBC工具类

* 目的：简化书写
* 分析：
	1、注册驱动也抽取
	2、抽取一个方法获取连接对象
		* 需求：不想传递参数(麻烦),还得保证工具类的通用性
		*  配置文件
	3、抽取一个方法释放资源
	 	
* 练习：
	*  需求：
		1、通过键盘录入用户名和密码
		2、判断用户是否登陆成功
			* select * from user where username = "" and password = "";
			* 如果这个sql有查询结果，则成功，反之，则失败

package cn.study.jdbc.customer;

import cn.study.jdbc.util.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

/**
 * Created by yanyuchun on 2020/7/29
 * *  需求：
 * 1、通过键盘录入用户名和密码
 * 2、判断用户是否登陆成功
 */
public class JdbcLogin {

    /**
     * 登陆方法
     *
     * @param username
     * @param password
     * @return
     */
    public boolean login(String username, String password) {
        if (username == null || password == null) {
            return false;
        }
        Connection coon = null;
        Statement stmt = null;
        ResultSet rs = null;
        // 连接数据库是否成功
        // 1、获取数据库连接
        try {
            coon = JDBCUtils.getConnection();
            // 2、创建sql执行对象
            stmt = coon.createStatement();
            // 3、创建sql语句
            String sql = "select  * from customer where  `user_name`='" + username + "' and `password`='" + password + "'";
            rs = stmt.executeQuery(sql);
            return rs.next();

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(rs,stmt,coon);
        }

        return false;
    }

    public static void main(String[] args) {
//        String username = "1";
//        String password = "1";
//        String sql = "select  * from customer where  `user_name`='" + username + "' and `password`='" + password + "'";
//        System.out.println(sql);

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();
        boolean flag = new JdbcLogin().login(username, password);
        if (flag){
            System.out.println("登陆成功，欢迎您："+username);
        }else {
            System.out.println("用户名或密码错误，登陆失败！");
        }
    }
}

JDBC控制事物

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