JDBC基础语句使用

/*
     *     插入数据
　　　　　*第一步：创建JDBC四大参数
　　　　　*第二步：加载驱动

　　　　　*第三步：定义要传入的sql语句
　　　　　*第四步：创建连接通道
　　　　　*第五步：执行给定的SQL语句

     */
    @Test
    public void test2() throws ClassNotFoundException, SQLException {
        // JDBC四大参数
        String driverClassName = "com.mysql.jdbc.Driver";
        // 创建连接
        String url = "jdbc:mysql://localhost:3306/db2";
        String user = "root";
        String password = "123";
        // 加载驱动 相当于 com.mysql.jdbc.Driver  driverClassName = new com.mysql.jdbc.Driver();
        Class.forName(driverClassName);// 加载Driver这个类,该类实现了java.sql.Driver的驱动
        //创建连接 连接Java程序和数据之间一个通道
        Connection connection = DriverManager.getConnection(url, user, password);
        //要传入的SQL语句
        String sql = "INSERT INTO stu values (57,'张三',18,'男','四川',1200)";
        // 创建一个 Statement 对象来将 SQL 语句发送到数据库。
        Statement statement = connection.createStatement();
        // 执行给定 SQL 语句,该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。
        //返回受影响的语句的行数
        statement.executeUpdate(sql);

    }

    public void test3() {
//        登录验证
        Scanner sc = new Scanner(System.in);
        Connection connection = null;
        ResultSet row = null;
        Statement statement = null;
        try {
//            创建联接
            connection = JdbcUtil.getConnection();

            System.out.println("请输入姓名");
            String sname = sc.nextLine();
            System.out.println("请输入年龄");
            int sage = sc.nextInt();
//        整理sql语句
            String sql = "select * from stu where sname ='" + sname + "' and " + "sage = '" + sage + "' ";
//        传递数据
            statement = connection.createStatement();
            row = statement.executeQuery(sql);
            if (row.next()) {
                System.out.println("登录成功");
            } else {
                System.out.println("登录失败");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            sc.close();

            try {
                if (row.next()) {
                    row.close();
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

由于每次连接很麻烦，所以可以封装一个方法，作为JDBC工具包，返回值是Connection对象，使用配置文件来传递我们想要的四大参数

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/*
*jdbc工具包
/
public class myUtil {
    static Properties property = new Properties();
//    Class.forName(driverClassName)
    static {
        try {
            property.load(new FileInputStream("db2.properties"));
            Class.forName(property.getProperty("driverClassName"));
            }
        catch (ClassNotFoundException e) {
                e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static  Connection getConnection() throws SQLException {
        String url =property.getProperty("url");
        String user =property.getProperty("user");
        String password =property.getProperty("password");
        
        return DriverManager.getConnection(url, user, password);
        
    }
}
/*
*测试方法
*/
    @Test
    public void test4() throws SQLException {// 修改数据
//        获取联接
        Connection connection = myUtil.getConnection();
        String sql = "update stu set sname = ? ,sage = ? where sid = 1";
//        传递数据
        PreparedStatement prep = connection.prepareStatement(sql);
        prep.setString(1, "张思");
        prep.setInt(2, 15);
        int executeUpdate = prep.executeUpdate();
        System.out.println(executeUpdate);

    }

1.使用别人封装好的jar包，好像还有连接池

2.使用PreparedStatement代替Statement，它的优点:使用？作为占位符，语句预编译，执行效率高;可以避免注入攻击（就是第二个登录方法里面输入das' or 1=1 -- dad das  也会登录成功 ）

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JdbcUtil {
    private static ComboPooledDataSource  datasource = new ComboPooledDataSource();

    //获取连接
    public static Connection getConnection() throws SQLException {
        return datasource.getConnection();
    }
}


    @Test
    public void test5() throws SQLException {// 添加数据
        Scanner sc = new Scanner(System.in);
//        获取连接
        Connection connection = JdbcUtil.getConnection();
//        传递数据
        String sql = "insert into stu(sid,sname,sage) values (?,?,?)";
        PreparedStatement prepareStatement = connection.prepareStatement(sql);
        System.out.println("输入要添加的ID");
        int sid = sc.nextInt();
        System.out.println("输入要添加的名字");
        String sname = sc.next();
        System.out.println("输入要添加的年龄");
        int sage = sc.nextInt();
        prepareStatement.setInt(1, sid);
        prepareStatement.setString(2, sname);
        prepareStatement.setInt(3, sage);
//        请求输入数据
        int executeUpdate = prepareStatement.executeUpdate();
        System.out.println(executeUpdate);

    }

在Eclipse中使用事务处理，实现账户转账中的问题

    /*
     * ui层
     */
    public static void main(String[] args) {
        Test01 t = new Test01();
        try {
            t.backService("张三", "李四", 100);
        } catch (Exception e) {
            System.out.println("转账失败");
        }
    }

    /*
     * service层的转账方法
     */
    public void backService(String from, String to, int money) throws Exception {// 事务操作,保证转账正常
//        创建同一个连接
        Connection con = null;
        try {
            // 通过工具包创建与数据库的连接
            con = JdbcUtil.getConnection();
            // 开启手动事务
            con.setAutoCommit(false);
            // 调用dao层更新要存储的数据 ,from账户中的钱减少,to账户中的钱增多
            updateAccount(con, from, -money);
            //人为制造一个异常,假设from 转账成功 ,但是to没有收到钱,看数据库的数据回滚没有
//            if(true) throw new Exception();  //当开启异常是转账失败,数据回滚 ,当关闭时成功转账
            updateAccount(con, to, money);
            //如果正常执行,则提交事务,此时数据库的值会改变  commit 承诺
            con.commit(); 
        } catch (SQLException e) {
            //出现异常的处理方式是回滚事务(意思就是更改的信息不保存到数据库,还原到调用之前)
             try {
                con.rollback();
            } catch (SQLException e1) {
                System.out.println("回滚失败");
            }
        }
    }

    /*
     * dao层执行数据的存储的方法
     */
    public void updateAccount(Connection con, String bname, int bbalan) throws SQLException {
        // 已经创建连接,可以传递数据,使用mysql 语句
        String sql = "update back set bbalan = bbalan + ? where bname = ? ";
        PreparedStatement prepareStatement = con.prepareStatement(sql);
        prepareStatement.setInt(1, bbalan);
        prepareStatement.setString(2, bname);
//        请求修改
        prepareStatement.executeUpdate();

    }

}

/*
 * 执行查询操作，如果rs查询结果不为空，如果有下一个值，就取出值，数据库中的字段是 id int,name varchar(10),address varchar(10)
 * 获取查询结果有两种方式，一种是通过列索引，第一个的索引为一;第二种是通过列字段作为参数获取
 */
    @Test
    public void test02() throws ClassNotFoundException, SQLException {
        Connection connection = JdbcUtils.getConnection();
        //查询操作:
        String sql="select * from student";
　　　　　　　//预编译sql语句，如果发现第二次调用的sql语句和第一次相同，则用以前的
        Statement statement = connection.createStatement();
        //executeQuery()用来执行查询，结果ResultSet中存储的是查询结果
        ResultSet rs = statement.executeQuery(sql);
        if(rs!=null) {
            while(rs.next()) {
                //JDBC的下标从1开始
                System.out.println(rs.getInt(1));
                System.out.println(rs.getString(2));
                System.out.println(rs.getString("address"));
            }
        }
        rs.close();
        statement.close();
        connection.close();
    }

JDBC:JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。
意思就是通过Java代码操作数据库

常见的JDBC组件：

JDBC API提供了以下接口和类：

• DriverManager:
  

  概念: 属于java.sql包,用于管理数据库驱动程序的类

  作用： 处理驱动程序的加载和建立新数据库连接

  常用静态方法：
  getConnection(String url,String userName,String password) ,该方法返回一个Connection类对象

• Driver: 此接口处理与数据库服务器的通信。

• Connection : 

  Connection接口的实现类即上文的Connection类，概念及作用等同。

  作用：

  （1）Connection对象表示数据库的连接状态；- - 保存DriverManager()方法的返回值。

  （2） Connection接口提供了多种数据库操作的方法：

  常用的几种方法：
  1.处理sql语句（常用的三种如下）： - - 处理的过程 ：编译/预编译sql语句，还没执行
  (1) stamement(String sql) - - 返回的是一个Statement对象
  (2) preparedStatement(String sql) - - 返回的是一个PreparedStatement对象
  (3)callabStatement(String sql) - - 返回的是一个CallabStatement对象
  2.控制事务提交
  (1) setAutoCommit(true/false) - - true为打开自动提交，false为关闭自动提交。（默认自动提交）
  3.控制事务回滚
  rollback()
  4.关闭数据库连接
  close()

• Statement : 使用接口提交到数据库的SQL语句创建的对象。一些派生的接口接受，除了执行存储过程的参数。

• ResultSet: 这些对象保存后，使用Statement对象执行SQL查询从数据库中检索数据。它作为一个迭代器，让您可以通过它的数据移动。

• SQLException: 这个类处理的数据库应用程序中发生的任何错误。

java有连接各种数据库的接口，由SUN官方提供，不同的数据库厂商自己写自己需要的接口对应的JDBC实现类，该实现类封装成jar包，程序员通过导入jar包，使用接口实现类来进行两者的搭桥的作用（乱理解的，以后补充）

反射:
程序在运行时可以获取类的字节码对象，动态操作对象：创建对象，给属性赋值，调用方法

JDBC的使用
导入MySQL数据库驱动jar包:MySQL官方提供的操作MySQL数据库必须要的驱动包
四大参数
核心API
DriverManager:
getConnection()
Connection
createStatement()   //创建执行SQL语句的对象
Statement
String sql=" ('"+name+"', "
executeUpdate(sql)  更改数据库的值，返回值是受影响的行数
executeQuery(sql)   查询数据库的值，，返回值是一个resultSet对象，存储的是需要的值
ResultSet   一个迭代器，和集合中的迭代器差不多，可以获取存储的值，通过while循环

DriverManager:
getConnection()
String sql=" ?,?";
Connection
preparedStatement(sql)   //statement的子接口，更好用
pstmt.setInt()   设定int型的值
pstmt.setString()
PreparedStatement  

executeUpdate()
executeQuery()
ResultSet

PreparedStatement:优点:语句预编译，执行效率高;可以避免注入攻击

使用Properties封装四大参数

连接:
使用连接池管理连接
集合
初始大小
扩充容量
最大容量
最小容量
使用结束，归还不是销毁

连接池:
DBCP
C3P0
Druid

使用C3P0连接池:
添加jar包：c3p0的核心包和依赖包，不要添加Oracle的依赖包
添加配置文件:配置文件名字不能改，位置只能放在类路径的根目录下(scr)
删除我们的db.properties
修改JdbcUtils类

事务处理:以后的Spring框架AOP管理事务

下订单:
订单表添加一条数据
订单条目表中添加多条数据

事务:一组操作，要执行都执行，不执行都不执行
四大特性:ACID
原子性:原子操作，一个整体
一致性:事务在执行前后，数据处于一个一致状态
转账
隔离性:事务在操作过程中，其他程序不能访问该数据
持久性:事务的执行结果最终会提交到数据库

数据库的事务操作默认是自动事务:
每一条独立的语句就是一个单独的事务

UI
Service
Dao

事务的概念本身是数据库的，真实的项目中事务是在业务层控制
JDBC中事务的提交和回滚的方法在Connection对象中,Java中控制一个事务必须使用同一个连接

Java中控制事务处理