当前位置: 奥门金沙手机娱乐网址 > 数据库 > 正文

让我们来谈谈JDBC

时间:2019-10-12 10:43来源:数据库
JDBC的简短介绍 1.JDBC 概念 JDBC : Java DatabaseConnectivity,java连接数据库,使用Java操作数据库的手艺。 实质 :其实就是sun公司定义的一套操作全数关系型数据库的准则,即接口。 依次数据

JDBC的简短介绍

1.JDBC

概念

  • JDBC : Java Database Connectivity,java连接数据库,使用Java操作数据库的手艺。
  • 实质 : 其实就是sun公司定义的一套操作全数关系型数据库的准则,即接口。
    依次数据库厂家去完成那套接口,提供数据库操作驱动jar包,大家得以采纳那套
    接口进行(JDBC)编制程序,真正施行的代码是驱动jar包的落到实处类。

    1)JDBC简介

迅猛入门

本身使用的是jdk10和mysql-connector-java-5.1.45-bin.jar。

步骤:

  1. 导入驱动jar包
    • 项目根目录成立文件夹libs。
    • 将mysql-connector-java-5.1.45-bin.jar复制到libs目录下
    • 右击libs下,Add as Library将jar包导入项目中
  2. 注册驱动
  3. 赢得数据库连接对象(Collection)
  4. 定义sql
  5. 收获试行sql语句的对象 Statement
  6. 实践sql,接受重返结果(ResultSet)
  7. 管理结果
  8. 刑释能源

     // 2. 注册驱动
     Class.forName("com.mysql.jdbc.Driver");
     // 3. 获取连接对象Collection
     Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "nrblwbb7");
     // 4. 定义sql
     String sql = "UPDATE STUDENT SET AGE = 23 WHERE NAME = '王智'";
     // 5. 获取执行sql语句的对象 Statement
     Statement statement = conn.createStatement();
     // 6. 执行sql,接受返回结果(ResultSet)
     int result = statement.executeUpdate(sql);
     // 7. 处理结果
     System.out.println(result);
     // 8. 释放资源
     statement.close();
     conn.close();
    

        - JDBC正是Java中三番五次数据库格局

详解各样对象

  1. DriverManager:驱动管理对象
  2. Connection:数据库连接对象
  3. Statement:执行sql对象
  4. ResultSet:结果集对象
  5. PreparedStatement :执行sql对象

        - 大家能够透过JDBC来试行SQL语句。

DriverManager

功能:

  1. 登记驱动:告诉程序该选择哪一个数据库驱动jar

    • 使用的秘技: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. 获得数据库连接

    • 方法:static Connection getConnection(String url, String user, String password)
    • 参数:
      • url:钦定连接的不二等秘书籍
        • 语法:jdbc:mysql://ip地址(域名):端口号/数据库名称
        • 例子:jdbc:mysql://localhost:3306/db
        • 细节:假使三番五次的是本机mysql服务器,何况mysql服务暗许端口是3306,则url能够简写为:jdbc:mysql:///数据库名称
        • jdbc是一而再数据库的情商,mysql是延续mysql数据库的子左券
      • user:用户名
      • password:密码

 

Collection连接对象

功能:

  1. 猎取施行sql的目的
    • Statement createStatement()
    • PreparedStatement prepareStatement(String sql)
  2. 处总管业
    • 拉开事务:setAutoCommit(boolean autoCommit) :调用该方法设置参数为false,即展开事务
    • 付出业务:commit()
    • 回滚事务:rollback()

    2)获取数据库连接

Statement实行静态sql对象

功能:

  1. 执行sql
    • boolean execute(String sql) :能够施行大肆的sql (驾驭)
    • int executeUpdate(String sql) :执行DML(insert、update、delete)语句、DDL(create,alter、drop)语句
      • 重返值:影响的行数,能够因而那几个影响的行数决断DML语句是不是执行成功 重回值>0的则试行成功,反之,则失败。
    • ResultSet executeQuery(String sql) :执行DQL(select)语句

插入比如:

 public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try {
            // 1. 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2. 获取连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3?useSSL=true", "root", "nrblwbb7");
            // 3. 创建sql
            String sql = "INSERT INTO ACCOUNT VALUES (NULL,'网址',2000)";
            // 4. 获取执行sql对象
            stmt = conn.createStatement();
            // 5. 执行sql
            int count = stmt.executeUpdate(sql);
            // 6. 处理结果
            System.out.println("影响的行数为:" + count);
            if(count > 0){
                System.out.println("插入成功");
            }else{
                System.out.println("操作失败");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 7. 释放资源
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }
  }

修改比方:

 public static void main(String[] args) {
        /**
         * 由于Connection和Statement实现了AutoCloseable接口,所以可以使用自动关闭
         */
        try(
                // 2.获取Connection对象
                Connection conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/db3?useSSL=true",
                        "root",
                        "nrblwbb7") ;
                // 3. 获取Statement对象
                Statement stmt = conn.createStatement()
                ){
            // 1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 4. 创建sql
            String sql = "UPDATE ACCOUNT SET BALANCE = 1500 WHERE NAME = '网址'";
            // 5. 执行sql
            int count = stmt.executeUpdate(sql);
            // 6. 处理结果
            System.out.println(count);
            if(count > 0){
                System.out.println("修改成功");
            }else{
                System.out.println("操作失败或者记录未更改");
            }
            // 7. 关闭连接,由于try..with..resource会自动关闭,所以无须担心
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

剔除举个例子:

 public static void main(String[] args) {
        /**
         * 由于Connection和Statement实现了AutoCloseable接口,所以可以使用自动关闭
         */
        try(
                // 2.获取Connection对象
                Connection conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/db3?useSSL=true",
                        "root",
                        "nrblwbb7") ;
                // 3. 获取Statement对象
                Statement stmt = conn.createStatement()
                ){
            // 1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 4. 创建sql
            String sql = "DELETE FROM ACCOUNT WHERE NAME = '网址'";
            // 5. 执行sql
            int count = stmt.executeUpdate(sql);
            // 6. 处理结果
            System.out.println(count);
            if(count > 0){
                System.out.println("删除成功");
            }else{
                System.out.println("删除失败");
            }
            // 7. 关闭连接,由于try..with..resource会自动关闭,所以无须担心
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

图片 1

ResultSet:结果及对象,封装查询结果

功能:

  1. 包裹查询结果:
    • boolean next(): 游标向下活动一行,决断当前行是不是是最终一行最后(是或不是有数据),倘若是,则赶回false,借使不是则赶回true
    • getXxx(参数):获取数据
      • Xxx:代表数据类型 如: int getInt() , String getString()
      • 参数:
        1. int:代表列的数码,从1上马 如: getString(1)
        2. String:代表列名称。 如: getDouble("balance")
    • 注意:
      • 接纳手续:
        1. 游标向下活动一行
        2. 看清是还是不是有数量
        3. 获取数据

举个轻松例子:

 @Test
    public void selectDemo(){
        try {
            // 1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.创建sql语句
            String sql = "select * from account";
            try(
                    // 3.获取连接对象
                    Connection conn = DriverManager.getConnection(
                            "jdbc:mysql://localhost:3306/db3?useSSL=true",
                            "root",
                            "root");
                    // 4.获取执行sql语句对象
                    Statement stmt = conn.createStatement()
            ){
                // 5.执行sql
                ResultSet rs = stmt.executeQuery(sql);
                // 6.处理结果集
                while(rs.next()){
                    // 获取id
                    int id = rs.getInt("id");
                    // 获取姓名
                    String name = rs.getString("name");
                    // 获取账户余额
                    double balance = rs.getDouble("balance");
                    // 正确的处理应该是封装为对象,进行处理,这就简单展示下
                    System.out.println("id = " + id + ", name = " + name + ", balance = " + balance);
                }

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

    }

 

PreparedStatement:推行动态sql的对象

功能:

  1. 实施动态的sql
    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.45-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. 释放能源
    5. 留意:前期都会动用PreparedStatement来形成增加和删除改查的兼具操作
      1. 能够免备SQL注入
      2. 频率更加高

  - java.sql.Connection 数据库连接

包装工具类

src下db.properties的信息:

# 驱动
driver=com.mysql.jdbc.Driver
# url
url=jdbc:mysql://127.0.0.1:3306/db3?useSSL=true
# 用户
username=root
# 密码
password=root

打包的工具类如下:

public class JDBCUtils {

    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    static{
        try {
            // 读取配置文件
            InputStream inputStream = JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties pro = new Properties();
            pro.load(inputStream);
            // 静态变量赋值
            driver = pro.getProperty("driver");
            url = pro.getProperty("url");
            username = pro.getProperty("username");
            password = pro.getProperty("password");
            // 注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接对象
     * @return 返回连接对象
     */
    public static Connection getConn() throws SQLException {
        return DriverManager.getConnection(url,username,password);
    }

    /**
     * 关闭资源
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt,Connection conn){
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭资源
     * @param rs
     * @param stmt
     * @param conn
     */
    public static void close(ResultSet rs, Statement stmt, Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

        - 大家对数据库的满贯操作都以从获取Connection发轫

事务管理

  1. 政工:二个包罗八个步骤的事务操作。假使那些专门的学问操作被事务管理,则那三个步骤要么同有时间打响,要么同时战败。
  2. 操作:
    1. 敞开事务
    2. 提交业务
    3. 回滚事务
  3. 采纳Connection对象来保管事务

    • 开启事务:setAutoCommit(boolean autoCommit) :调用该格局设置参数为false,即展开事务
      • 在执行sql从前开启事务
    • 付给业务:commit()
      • 当全数sql都实践完提交业务
    • 回滚事务:rollback()
      • 在catch中回滚事务

    测试:

     public static void main(String[] args) {
         Connection conn = null;
         PreparedStatement pstmt1 = null;
         PreparedStatement pstmt2 = null;
         try {
             // 1.创建sql,转账的sql
             String sql1 = "UPDATE ACCOUNT SET BALANCE = BALANCE - ? WHERE ID = ?";
             String sql2 = "UPDATE ACCOUNT SET BALANCE = BALANCE + ? WHERE ID = ?";
             // 2.获取连接对象
             conn = JDBCUtils.getConn();
    
             // 开启事务
             conn.setAutoCommit(false);
    
             // 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) {
             if(conn != null) {
                 try {
                     // 事务回滚
                     conn.rollback();
                 } catch (SQLException e1) {
                     e1.printStackTrace();
                 }
             }
             e.printStackTrace();
         } finally {
             JDBCUtils.close(pstmt1,conn);
             JDBCUtils.close(pstmt2,null);
         }
     }
    

        - 获取数据库连接的七个参数:

            1.数据库的地点 url

                语法:jdbc:子合同:厂商内容

                MySQl的格式:jdbc:mysql://主机名:端口号/数据库名字

                例子:jdbc:mysql://localhost:3306/test

 

            2.顾客名 user 连接数据库使用的顾客名

            3.密码 password 数据库的密码

            4.数据库驱动全类名 driverClass

 

        - 基本步骤:

            1.导入数据库驱动的jar包

                mysql-connector-java-5.1.37-bin.jar

            2.备选多个参数

                - url

                - user

                - password

                - driverClass

            3.加载数据库驱动

                Class.forName(driverClass)

            4.经过DriverManager来获取数据库连接   

                static Connection getConnection(String url, String user, String password)

 

        - 问题:

            - 在JDBC的代码中有如下一行代码:

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

                - 大家开掘那行代码和任何的代码未有上下文关系,就是不写她编译也不会出错。

                    并且,那行代码不写也好使,那是干什么吗?

                    - Class.forName() 首若是将五个类加载进的虚构机。

                    - 通过观看mysql的Driver的源码,发掘类中有三个静态代码块:

                        static {

                            try {

                                java.sql.DriverManager.registerDriver(new Driver());

                            } catch (SQLException E) {

                                throw new RuntimeException("Can't register driver!");

                            }

                        }

                    - 静态代码块会在类被加载进设想机时就能进行,也正是当大家调用          Class.forName("com.mysql.jdbc.Driver");

                        现在,该静态代码块会及时实行。

                        而静态代码块中,有如下代码:

                            java.sql.DriverManager.registerDriver(new Driver());

                        那几个代码会将数据库驱动注册进DriverManager中。

 

                    - 可是我们以此东西不写也好使,因为在JDBC4随后,程序会活动加载数据库驱动。

                    - 尽管是那般,不过大家渴求那行代码必须写。尤其是在web工程,更是必得写。   

 

 

        - 核心类:

            - java.sql.DriverManager

                - 数据库驱动的管理器,担负加载数据库的驱动获取数据库连接

                - static Connection getConnection(String url, String user, String password) 

                    - getConnection方法用来通过url地址,客商名,密码等参数来收获数据库连接的

 

            - java.sql.Connection

                - 数据库连接

                - Statement createStatement() 

                    - 创立叁个Statement对象,通过Statement对象来实施SQL语句

 

            - java.sql.Statement

                - SQL语句的实行器

                    - boolean execute(String sql) 

                        - 实践一条SQL语句,并重回多个布尔值,推行成功重返true,实施倒闭再次来到false。用的非常的少

                    - ResultSet executeQuery(String sql) 

                        - 实践查询的SQL语句,并再次回到贰个结果集

                    - int executeUpdate(String sql) 

                        - 奉行修改数据的SQL语句(增加和删除改),并赶回受影响的行数

 

            - java.sql.ResultSet

                - 查询到的数据的结果集,我们透过JDBC查询数据库得到的数量,都封装在ResultSet中

                - boolean next() 

                    - 调控光标向下活动一行,要是光标当前地点是afterLast则赶回false,告诉您相当少了,就别读了。

                        倘使光标移动以后,未有在afterLast则赶回true,能够读取数据。

 

                - 在ResultSet有很多getXxx(int),比如getString(),getInt(),getByte()。

                    通过这几个办法能够读取当前行的数码,它们须求一个int值作为参数,

                        int指的是读取数据的列数。

                    列数是从1起头的。

 

                - 在ResultSet中还会有众多getXxx(String),它和下边包车型大巴措施的成效同样,

                    只可是它们需求的都以String类型的参数,参数代表的是当下的列名,

                        比如:大家要获得id的值

                            getInt("id")

                        要获取name的值

                            getString("name")

                    注意:要是查询的SQL使用了外号,则列名以别称叫准。

 

    3)数据的增加和删除改

        //成立一个SQL推行器

        Statement stat = conn.createStatement();

 

        //成立四个SQL语句

        String sql = "INSERT INTO t_stu(`name` , age) VALUES('沙僧',28)";

 

        //执行SQL语句

        //executeUpdate用来实践一条修改SQL的说话

 

        //它须要八个String类型sql作为参数,并会回来一个int型的值,该值表示SQL语句推行现在影响到的行数

        int count = stat.executeUpdate(sql);

 

    4)数据的询问

        //创建Statement对象

        Statement stmt = conn.createStatement();

        //创立一个SQL语句

        String sql = "SELECT id, name sname, age FROM t_stu WHERE id=2";

        //实行查询

        ResultSet rs = stmt.executeQuery(sql);

        //调整光标下移一行

        //借使当前行有数据,则读取

        if(rs.next()){

 

            //获取id,name,age

            int id = rs.getInt("id");

            String name = rs.getString("sname");

            int age = rs.getInt("age");

 

            System.out.println(id+"--"+name+"--"+age);

        }

 

        > 查询操作和修改的重大分裂的是,查询使用executeQuery(),

            它会回去ResultSet结果集,大家必要对结果集举行读取。

 

        > 当我们只必要读取三个数码时,用if。

            当须要读取全体数据时,用while

 

        > 代码的正规:

            - Connection、Statement、ResultSet,这么些能源都是必要和数目建立连接的

                这么些资源我们并非总要求动用,当大家不适用这个资源,须要将这一个能源关闭。

            - 关闭能源顺序:

                从后往前关:

                    先关 ResultSet

                    在关 Statement

                    最后关 Connection

            - 示例代码:

                //定义八个变量

                Connection conn = null;

                Statement stmt = null;

                ResultSet rs = null;

 

                try{

 

                }catch(Exception e){

                    e.printStackTrace();

                }finally{

 

                    if(rs!=null){

                        //关闭ResulSet

                        try {

                            rs.close();

                        } catch (SQLException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                        }

                    }

 

                    if(stmt != null){

                        try {

                            stmt.close();

                        } catch (SQLException e) {

                            e.printStackTrace();

                        }

                    }

 

                    if(conn != null){

                        try {

                            conn.close();

                        } catch (SQLException e) {

                            e.printStackTrace();

                        }

                    }

 

                }

 

图片 2

 

 

2.JDBC

    1) SQL注入

        > 近来大家的接纳的是Statement来进行SQL语句

            而大家传递的参数时经过拼接字符串的款型增加进SQL语句

        > "SELECT * FROM t_user WHERE username='"+username+"' AND password='"+password+"'"   

        > 这种格局固然寻常客户的拜望,难点非常的小,可是只要出现恶心的客商,

            他要是传递了那样一组参数 客商名 : a' O君越 'a'='a  密码:a' OEnclave 'a'='a

        > 那七个参数假设拼接进SQL语句,SQL语句会化为如下的景况:

            "SELECT * FROM t_user WHERE username='a' OR 'a'='a' AND password='a' OR 'a'='a'"   

        > 通过这种特有的参数,导致大家SQL语句的语义完全改观,那样固然客商名和密码不科学也能够登陆

            那样就对我们的网站带来极大的安全隐患

        > 解决:

            1.在客商输入时开展验证,验证用户名中是不是含有特殊字符 ' " 等等

            2.假设大家一向使用Statement则永久都会有SQL注入的隐患,所以最棒实施方案是不采用Statement

                而是选拔PreparedStatement

 

    2) PreparedStatement

        > java.sql.PreparedStatement --> 预编写翻译的Statement

        > PreparedStatement是Statement的子接口,使用方式和Statement类似,可是它在Statement做了部分扩展。

        > 获取PreparedStatement是经过Connection的prepareStatement()的法子获得的,这些办法要求传四个SQL语句,

            当我们透过SQL语句获取贰个PreparedStatement时,JDBC会将SQL语句首发送给MySQL,

                让大家的数据库对SQL语句进行预编写翻译操作。

        > 使用PreparedStatement的好处:

            1.PreparedStatement行使占位符来替换SQL语句中的变量,更方便编写和阅读,维护起来更加的粗略。

            2.MySQL在实践一条SQL语句时,要分七个步骤:

                1) 编写翻译SQL语句,检查SQL语句是或不是有语法错误

                2) 执行SQL语句

                使用Statement时,每一遍都亟需张开那三个步骤,而MySQL能够对已经编写翻译过的话语进行缓存,

                    使用PreparedStatement,推行三遍之后,会对SQL语句实行缓存,下一次再一次实行时成效越来越高。

                那么些优点显示的不举世瞩目。

            3.使用PreparedStatement时SQL语句会付出MySQL举办预编写翻译,预编写翻译的长河MySQL会将SQL语句,

                调换为一个临近于Java中艺术的东西,而笔者辈的这几个填充的占位符,会以艺术的参数的样式发送给MySQL

              那样就算传递在乎外的参数,也无法改变SQL语义,所以它实用的幸免了SQL注入的标题。

 

        > 所以我们实在的运用中绝不可够使用Statement而是使用PreparedStatement

 

    3) 大数据

        - 相当大的数额

        - 大数据主要分三种:

            1.大文本数据

            2.大的字节数据

        - mysql对文件的高低有限量,也正是超越一定的大小未来,文件将不能够插入进数据库,插入时会抛出特别

        - 我们能够修改mysql对文件的深浅的限量,修改my.ini文件

            在my.ini文件中增多如下配置

                max_allowed_packet = 10M

 

    4) 批处理(batch)

        - 批处理指的是二回操作中实行多条SQL语句

        - 批管理比较于二次三遍推行功用会增高广大

        - 批管理主若是分两步:

            1.就要试行的SQL语句保存

            2.执行SQL语句

        - Statement和PreparedStatement都协理批管理操作,这里大家只需求掌握PreparedStatement的批管理格局:

            - 方法:

                void addBatch()

                    - 将要实施的SQL先保存起来,先不试行

                    - 这一个艺术在安装完全部的占位符之后调用

                int[] executeBatch()

                    - 那么些点子用来实行SQL语句,这几个方法会将批管理中存有SQL语句实行

 

        - mysql暗中同意批管理是关门的,所以大家还必要去开发mysql的批管理:

                rewriteBatchedStatements=true

            我们必要将上述的参数增多到mysql的url地址中

 

        - 注意:低版本的mysql-jdbc驱动也不援救批管理

 

    5) 事务(Transaction)

        - 在开采中我们的八个政工往往供给同期操作多个表,这个操作往往是不可分割,业务中的对数据库的往往操作,

            要么同一时间打响,要么全都退步。

        - 注意:大家在同三个业务中运用的数据库连接(Connection)必须是同一个。   

 

        - 事务的表征(ACID):

             原子性(atomicity)

                二个事务是贰个不可分割的劳作单位,事务中包罗的诸操作要么都做,要么都不做。

 

            一致性(consistency)

                事务必得是使数据库从一个一致性状态变到另贰个一致性状态。一致性与原子性是紧密相关的。

 

            隔离性(isolation)

                贰个作业的试行无法被其余业务苦恼。

                    即贰个专门的事行业内部部的操作及使用的数额对现身的其余事情是隔开分离的,并发实行的逐条业务之间不能够相互忧虑。

 

            持久性(durability)

                长久性也称长久性(permanence),指贰个作业一旦付出,它对数据库中数据的改换就应有是永恒性的。

                    接下去的此外操作或故障不该对其有任何影响。

 

        - 操作职业的着力步骤:

            1.敞开事务

                - 开启事务未来,大家只后的享有操作将都会在同二个政工个中

            2.操作数据库

                - 开启事务以往再去操作数据库,全数操作将不会直接提交到数据库中

            3.提交业务

                - 将修改应用到数据库

            4.回滚事务

                - 数据库操作进度中出现极度了,回滚事务,回滚事务以往,数据库形成开启事务在此以前的情事

 

        - mysql中的事务调节

            #拉开事务

            START TRANSACTION

 

            #回滚事务

            ROLLBACK

 

            #交给业务

            COMMIT

 

        - JDBC中的事务主要通过Connection对象来调整的

            1.敞开事务

                void setAutoCommit(boolean autoCommit) throws SQLException;

                - 设置职业是或不是自动提交,暗许是活动提交

                - 设置专门的职业手动提交

                    conn.setAutoCommit(false);

 

            2.付出业务

                void commit() throws SQLException;

                - 提交业务

                conn.commit()

 

            3.回滚事务

                void rollback() throws SQLException;

                - 回滚事务

                conn.rollback()

 

        - 事务调控的格式:

            //创立一个Connection

            Connection conn = null;

 

            try{

 

                //获取Connection

                conn = JDBCUtils.getConnection();

 

                //开启事务

                conn.setAutoCommit(false);

 

                //对数据库举行操作

 

                //操作成功,提交业务

                conn.commit();

 

            }catch(Exception e){

                e.printStackTrace();

 

                //回滚事务

                try {

                    conn.rollback();

                } catch (SQLException e1) {

                    e1.printStackTrace();

                }

 

            }finally{

                JDBCUtils.close(conn, null, null);

            }

 

    6) 数据库连接池

        > 数据库连接池就是贮存数据库连接(Connection)的成团

        > 大家赢得三个数据库连接是二个对峙很麻烦的长河,

            假设大家得到二个数据库连接,使用二回之后就给它停业了

                下一遍再去选用的时候将要重复创建一个新的数据库连接。

        > 所以我们提议了二个数据库连接池的概念,数据库连接池放的都以数据库连接(Connection)

            大家在去选拔数据库连接时候,不用再去重新创建数据库连接,而是平素从池中赢得,

                使用完的数据库连接,亦不是间接销毁,而是要放回到连接池。

        > 数据库连接池的常见的习性:

 

                初叶连接数量:数据连接池创立现在,保存数据库连接的数目

 

                最小空闲连接数:数据库连接池最少得未使用的数据库连接的数据

 

                最大空闲连接数:数据库连接池最大闲置连接数,当闲置连接数满了随后,将不会有另外总是步入池

 

                每一趟扩充连接数:当数据库连接都被挤占未来,贰次性扩大的数据库连接的个数

 

                最辛辛那提接数:数据库连接池的最大容积,当最洛桑接数饱和了,则不更创制新的数据库连接

 

                最大等待时间:当数据库连接池饱和以往,等待获取数据库连接的日子

 

        > 常见的数据库连接池

            - 全数的数据库连接池都急需贯彻DataSource,当使用数据库连接池时,大家便不再必要接纳DriverManger获取数据库连接

                而是选取DataSource。

                 - Connection getConnection()

                    - 从数据库连接池中收获数据库连接对象

 

            1.DBCP

                - DBCP是Apache出品的一款数据库连接

                - DBCP依赖于commons-pool

                - 使用DBCP须求导入五个jar包:

                    commons-dbcp-1.4.jar

                    commons-pool-1.5.5.jar

                - 当大家通过数据库连接池获取数据库连接未来,大家所取获得数据库连接已经不是我们了解的要命Connection

                    数据库连接池对Connection对象举办了打包,它修改Connection的close()方法,

                        再去调用close()数据库连接将不会真正关闭,而是要放回到数据库连接池中,供其余线程使用。

                - 核心类:

                    BasicDataSourceFactory

 

            2.C3P0(重点)

                - C3P0采取的是XML作为配置文件

                - 使用c3p0必要导入一个jar包:

                    c3p0-0.9.1.2.jar

                - 导入c3p0的布局文件:

                    1.配置文件的名字:c3p0-cofig.xml

                    2.布局文件需求置于类路线下(src)

                - 核心类:   

                    ComboPooledDataSource

                - 注意:

                    DataSource就也正是池子,大家的数据库连接都以从DataSource中获得的,

                        倘若程序中有四个DataSource的实例,那么我们说你还比不上不用数据库连接池。

                    所以大家的DataSource在类型中应该独有叁个实例。   

 

 

 

转发请表明出处!

多谢您的开卷。假如文章对你有用,那么请轻轻点个赞,以资慰勉。

 

 

 

编辑:数据库 本文来源:让我们来谈谈JDBC

关键词:

  • 上一篇:没有了
  • 下一篇:没有了