JDBC的使用

JDBC的使用

JDBC的使用

• 一、JDBC
• 二、JDBCUtils工具类
• 三、JDBC控制事务

一、JDBC

一套 *** 作所有关系型数据库的规则，即接口。

步骤：
1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar；
2. 注册驱动；
3. 获取数据库连接对象 Connection；
4. 定义sql；
5. 获取执行sql语句的对象 Statement；
6. 执行sql，接受返回结果；
7. 执行sql，接受返回结果；
8. 释放资源；

       //1、导包
            //在libs里面的包
        //2、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3、获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "root");
        //4、定义sql语句
        String sql = "update salarygrade set losalary=6000 where grade=1";
        //5、获取执行sql的对象 Statement
        Statement statement = conn.createStatement();
        //6、执行sql
        int count = statement.executeUpdate(sql);  //返回数据库中影响的行数
        //7、处理结果
        System.out.println(count);
        //8、释放资源
        statement.close();
        conn.close();

（1）DriverManager：驱动管理对象

1. 注册驱动：告诉程序该使用哪一个数据库驱动jar

Class.forName("com.mysql.jdbc.Driver");

2. 获取数据库连接

jdbc:mysql://ip地址(域名):端口号/数据库名称
jdbc:mysql://localhost:3306/db3
如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称

（2）Connection：数据库连接对象

1. 获取执行sql 的对象

* Statement createStatement()
* PreparedStatement prepareStatement(String sql)  
* 

2. 管理事务 

* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
* 提交事务：commit() 
* 回滚事务：rollback() 

（3）Statement：执行sql的对象

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

（4）ResultSet：结果集对象,封装查询结果

执行sql
* boolean next(): 游标向下移动一行，开始时指向表头，到表末尾返回false
* getXxx(参数):获取数据

(5) PreparedStatement：执行sql的对象

1. 解决sql注入问题：使用PreparedStatement对象来解决
2. 预编译的SQL：参数使用?作为占位符
3. 给？赋值:
		setXxx(参数1,参数2)
				* 参数1：？的位置编号 从1 开始
				* 参数2：？的值

二、JDBCUtils工具类

jdbc.properties配置文件

//具体代码
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    //将配置文件的读取放在静态代码块中，只要读取一次，随着类的加载而加载
    static {
        try {
            //创建properties集合类   加载并读取配置文件
            Properties pro = new Properties();
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL url1 = classLoader.getResource("jdbc.properties");
            String path = url1.getPath();
//            System.out.println(path);
            pro.load(new FileReader(path));
            //获取数据 赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            //注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    //获取连接对象
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,password);
    }
    public static void close(Statement stmt,Connection conn){
        //调用下面重载的方法 简化代码
    close(null,stmt,conn);
    }
    //重载方法
    public static void close(ResultSet resultSet,Statement statement, Connection connection){
        try {
            if (resultSet!=null)
                resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (statement!=null)
                statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (connection!=null)
                connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

三、JDBC控制事务

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

salarygrade表如下：

public class test7 {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement ps1 = null;
        PreparedStatement ps2 = null;
        try {
        //调用工具类获取连接对象
            connection = JDBCUtils.getConnection();
            connection.setAutoCommit(false); //开启事务
            //定义sql语句：将grade为1的losalary减1000，hisalary加1000；
            String sql = "update salarygrade set losalary=losalary-? where grade =?";
            String sql1 = "update salarygrade set hisalary=hisalary+? where grade =?";
            //获取执行sql语句的对象
            ps1 = connection.prepareStatement(sql);
            ps2 = connection.prepareStatement(sql1);
            //为？赋值
            ps1.setInt(1,1000);
            ps1.setInt(2,1);
            ps2.setInt(1,1000);
            ps2.setInt(2,1);
            //执行sql语句
            ps1.executeUpdate();
            //手动制造异常
            int a = 3/0;
            ps2.executeUpdate();
            connection.commit(); //事务提交
        } catch (Exception e) {
            try {
                connection.rollback(); //事务回滚
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        } finally {
        //调用工具类释放资源
            JDBCUtils.close(ps1,connection);
            JDBCUtils.close(ps2,null);
        }
    }
}