奥门威尼斯网址Java JDBC(二)

by admin on 2019年10月7日

JDBC的差不离介绍

JDBC概述

JDBC(Java Data Base
Connectivity,java数据库连年)是一种用于实践SQL语句的Java
API,可感到种种关周全据库提供统一访问,它由一组用Java语言编写的类和接口组成。是Java访谈数据库的标准规范
JDBC提供了一种规格,据此能够构建更加尖端的工具和接口,使数据库开采人士能够编写数据库应用程序。
JDBC须求连接驱动,驱动是多个设施要扩充通讯,满意一定通讯数据格式,数据格式由器械提供商规定,设备提供商为设备提供驱动软件,通过软件可以与该设备进行通讯

DBUtils

设若只使用JDBC进行支付,大家会发觉冗余代码过多,为了简化JDBC开采
,大家运用apache commons组件贰个成员:DBUtils。

Commons
DbUtils是Apache团伙提供的二个对JDBC开展轻松包装的开源工具类库,使用它亦可简化奥门威尼斯网址,JDBC应用程序的支付,同一时间也不会影响程序的天性。

 

概念

  • JDBC : Java Database
    Connectivity,java连接数据库,使用Java操作数据库的本事。
  • 真相 :
    其实就是sun公司定义的一套操作全数关系型数据库的条条框框,即接口。
    梯次数据库厂商去达成那套接口,提供数据库操作驱动jar包,大家能够利用那套
    接口实行(JDBC)编制程序,真正试行的代码是驱动jar包的贯彻类。

JDBC原理

ava提供访谈数据库标准称为JDBC,而生产厂家提供标准的贯彻类称为驱动

奥门威尼斯网址 1

image.png

JDBC是接口,驱动是接口的贯彻,未有驱动将不或者形成数据库连接,进而不能够操作数据库!各种数据库商家都须要提供温馨的驱动,用来一而再本身集团的数据库,也正是说驱动常常都由数据库生成厂家提供

概述

DBUtils是java编制程序中的数据库操作实用工具,小巧轻松实用。
DBUtils封装了对JDBC的操作,简化了JDBC操作,能够少写代码。
Dbutils多个着力职能介绍

  • QueryRunner中提供对sql语句操作的API
  • ResultSetHandler接口,用于定义select操作后,如何封装结果集
  • DbUtils类,它正是多少个工具类,定义了关闭能源与事务管理的不二秘籍

mysql :

马上入门

本身使用的是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开采步骤

  • 注册驱动.
  • 收获连接.
  • 获得说话奉行平台
  • 执行sql语句
  • 处理结果
  • 放活能源.

QueryRunner核心类

  • update(Connection conn, String sql, Object... params),用来完结表数据的加多、删除、更新操作
  • query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
    ,用来达成表数据的询问操作
//****** 四大金刚:  驱动类名、url、用户名、密码


//MySQL四大金刚

String driverClassname="com.mysql.jdbc.Driver"
String url="jdbc:mysql://localhost:23306/visitor?useSSL=true"
String username="root" 
String password="root"
//说明:  MySQL 5.7版本以后,url里要写明useSSL,记住,url是以jdbc打头。




//SQLServer四大金刚

String driverClassname="com.microsoft.sqlserver.jdbc.SQLServerDriver"
String url="jdbc:sqlserver://127.0.0.1:21433;databaseName=Exam;instanceName=DBServer;"
String username="sa" 
String password="sa"
//说明: url是以jdbc打头。如果有实例则要指定实例名称。

详解各种对象

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

导入驱动jar包

  • 创办lib目录,用于存放当前项目需求的具备jar包
  • 选料jar包,右键实行build path / Add to Build Path
![](https://upload-images.jianshu.io/upload_images/10282187-9cf5ec2d2c6bed1b.png)

image.png

添加

public void insert(){
    try {

        // 获取一个用来执行SQL语句的对象   
        QueryRunner qr = new QueryRunner();

        String sql = "INSERT INTO goods(name, price) VALUES(?, ?)";
        Object[] params = {"电视", 5500};
        Connection conn = JDBCUtils.getConnection();

        // 用来完成表数据的增加、删除、更新操作
        int line = qr.update(conn, sql, params);
        // 结果集处理
        System.out.println("line = " + line);

    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}

 

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:密码

API详解:注册驱动

代码:

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

JDBC标准定义驱动接口:java.sql.Driver,MySql驱动包提供了贯彻类:com.mysql.jdbc.Driver
DriverManager工具类,提供注册驱动的办法
registerDriver(),方法的参数是java.sql.Driver,所以大家得以经过如下语句进行挂号:
DriverManager.registerDriver(new com.mysql.jdbc.Driver());

如上代码不推荐使用,存在两地点相差
1.硬编码,前期不易于程序扩充和掩护
2.驱动被注册四回。
普普通通开荒大家使用Class.forName() 加载三个选择字符串描述的驱动类。
若是采取Class.forName()将类加载到内部存款和储蓄器,该类的静态代码将活动推行。
通过查询com.mysql.jdbc.Driver源码,大家开掘Driver类“主动”将和煦实行登记

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

更新

public void insert(){
    try {

        // 获取一个用来执行SQL语句的对象   
        QueryRunner qr = new QueryRunner();

        String sql = "UPDATE goods SET price = price + 3000 WHERE name=?";
        Object[] params = {"电视"};
        Connection conn = JDBCUtils.getConnection();

        // 用来完成表数据的增加、删除、更新操作
        int line = qr.update(conn, sql, params);
        // 结果集处理
        System.out.println("line = " + line);

    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}
Collection连接对象

功能:

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

API详解:获得链接

代码:

Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "123456");

收获连接须求艺术
DriverManager.getConnection(url, username, password),多个参数分别表示,url
需求连接数据库的职位(网址user顾客名 password 密码

url比较复杂,上面是mysql的url:
jdbc:mysql://localhost:3306/mydb

JDBC规定url的格式由三部分构成,每种部分中级使用冒号分隔。

率先局地是jdbc,那是一定的;
第二有些是数据库名称,那么连接mysql数据库,第二有的当然是mysql了;
其三有些是由数据库商家规定的,大家要求领会各样数据库商家的渴求,mysql的首盘部各自由数据库服务器的IP地址(localhost)、端口号(3306),以及DATABASE名称(mydb)组成。

删除

public void insert(){
    try {

        // 获取一个用来执行SQL语句的对象   
        QueryRunner qr = new QueryRunner();

        String sql = "DELETE goods WHERE name=?";
        Object[] params = {"电视"};
        Connection conn = JDBCUtils.getConnection();

        // 用来完成表数据的增加、删除、更新操作
        int line = qr.update(conn, sql, params);
        // 结果集处理
        System.out.println("line = " + line);

    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}
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();
        }
    }

预管理对象executeUpdate方法

透过预管理对象的executeUpdate方法,完毕记录的insert\update\delete语句的施行。操作格式统一如下:

  • 注册驱动
  • 得到连接
  • 获取预管理对象
  • SQL语句占位符设置实际参数
  • 执行SQL语句
  • 放活能源

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;


public class Test {
    public static void main(String[] args) throws Exception {
        updata();
    }
    public static void updata() throws Exception {
        // 注册驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbc", "root", "123456");

        // 获得预处理对象中
        String sql = "UPDATE goods SET name=? where id=?";
        PreparedStatement stat = conn.prepareStatement(sql);

        // SQL语句占位符设置实际参数
        stat.setString(1, "数码产品");
        stat.setInt(2, 1);

        // 执行SQL语句
        int line = stat.executeUpdate();
        System.out.println("更新记录数:" + line);

        // 释放资源
        stat.close();
        conn.close();
    }
}

切切实实的能够看看已下教程
https://www.yiibai.com/jdbc/

QueryRunner落成查询操作

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();
        }

    }

JDBC工具类

“获得数据库连接”操作,将要随后的增加和删除改查全体机能中都设有,能够打包工具类JDBCUtils。提供获取连接对象的方法,从而到达代码的双重利用。
该工具类提供格局:public static Connection getConnection ()。
代码如下:

package com.cuzz;
/*
 *  实现JDBC的工具类
 *  定义方法,直接返回数据库的连接对象
 *  
 *  写关闭方法
 */

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

public class JDBCUtils {
    private JDBCUtils(){}
    private static Connection con ;

    static{
        try{
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/mybase";
            String username="root";
            String password="123";
            con = DriverManager.getConnection(url, username, password);
        }catch(Exception ex){
            throw new RuntimeException(ex+"数据库连接失败");
        }
    }

    /*
     * 定义静态方法,返回数据库的连接对象
     */
    public static Connection getConnection(){
        return con;
    }


    public static void close(Connection con,Statement stat){

         if(stat!=null){
             try{
                 stat.close();
             }catch(SQLException ex){}
         }

         if(con!=null){
             try{
                 con.close();
             }catch(SQLException ex){}
         } 
    }


    public static void close(Connection con, Statement stat, ResultSet rs){
         if(rs!=null){
             try{
                 rs.close();
             }catch(SQLException ex){}
         }

         if(stat!=null){
             try{
                 stat.close();
             }catch(SQLException ex){}
         }

         if(con!=null){
             try{
                 con.close();
             }catch(SQLException ex){}
         } 
    }
}

ResultSetHandler结果集管理类

  • ArrayHandler将结果聚集的率先条记下封装到多少个Object[]数组中,数组中的每一个要素正是那条记下中的每叁个字段的值
  • ArrayListHandler
    将结果聚集的每一条记下都卷入到一个Object[]数组中,将那几个数组在封装到List集合中
  • BeanHandler将结果集中第一条记下封装到贰个钦定的javaBean
  • BeanListHandler将结果集中每一条记下封装到内定的javaBean中,将这些javaBean在封装到List集合中
  • ColumnListHandler将结果聚焦钦命的列的字段值,封装到叁个List集合中
  • ScalarHandler它是用以单数据,比如·select count(*) from` 表操作
  • MapHandler将结果集第一行封装到Map集合中,Key 列名,Value
    该列数据
  • MapListHandler 将结果集第一行封装到Map集合中,Key 列名,
    Value 该列数据,Map会集存款和储蓄到List集合
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. 频率更加高

properties配置文件

支出中收获接二连三的4个参数(驱动、U奥德赛L、顾客名、密码)平时都设有配置文件中,方便早先时期维护,程序一旦要求改动数据库,只须求修改配置文件就能够。
普普通通处境下,大家习于旧贯使用properties文件,此文件我们将做如下需求:

  • 文本地方:放肆,提议src下
  • 文件名称:任性,扩张名称为properties
  • 文件内容:一行一组数据,格式是"key=value"
    key命名自定义,假使是多个单词,习于旧贯使用点分隔。比如:jdbc.driver
    value值不扶助粤语,借使必要使用非希腊语字符,将进行unicode转换

JavaBean

JavaBean即是三个类,在支付中常用封装数据
全数如下特点

  • 内需贯彻接口:java.io.Serializable
    ,常常完毕接口那步骤省略了,不会影响程序。
  • 提供个人字段:private类型字段名;
  • 提供getter/setter方法:
  • 提供无参构造

装进工具类

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();
            }
        }
    }

}

成立布局文件

在档期的顺序跟目录下,创立文件,输入”db.properties”文件名
在”db.properties”文件中写下安排

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb
user=root
password=123456

ArrayHandler与ArrayListHandler查询

  • ArrayHandler:将结果聚焦的第一条记下封装到多少个Object[]数组中,数组中的每八个因素就是那条记下中的每贰个字段的值

public class Demo {

    public void method(){
        try {

            // 获取QueryRunner对象
            QueryRunner qr = new QueryRunner();

            // 执行SQL语句
            String sql = "SELECT * FROM goods";

            Object[] params = {};
            Connection conn = JDBCUtils.getConnection();
            Object[] objArray = qr.query(conn, sql, new ArrayHandler(), params);

            // 结果集的处理
            System.out.println( Arrays.toString(objArray) );

            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  • ArrayListHandler:将结果聚集的每一条记下都卷入到多少个Object[]数组中,将那么些数组在封装到List集合中

public class Demo {

    public void method(){
        try {

            // 获取QueryRunner对象
            QueryRunner qr = new QueryRunner();

            // 执行SQL语句
            String sql = "SELECT * FROM goods WHERE price>?";

            Object[] params = {2000};
            Connection conn = JDBCUtils.getConnection();
            List<Object[]> list = qr.query(conn, sql, new ArrayHandler(), params);

            // 结果集的处理
            for (Object[] objArray : list) {
                System.out.println(Arrays.toString(objArray));
            }

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

事务管理

  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);
         }
     }
    

加载配置文件:Properties对象

JDBCUtilsConfig.java中编辑代码

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;

/*
 *  编写数据库连接的工具类,JDBC工具类
 *  获取连接对象采用读取配置文件方式
 *  读取文件获取连接,执行一次,static{}
 */
public class JDBCUtilsConfig {
    private static Connection con ;
    private static String driverClass;
    private static String url;
    private static String username;
    private static String password;

    static{
        try{
            readConfig();
            Class.forName(driverClass);
            con = DriverManager.getConnection(url, username, password);
        }catch(Exception ex){
            throw new RuntimeException("数据库连接失败");
        }
    }

    private static void readConfig()throws Exception{
        InputStream in = JDBCUtilsConfig.class.getClassLoader().getResourceAsStream("database.properties");
         Properties pro = new Properties();
         pro.load(in);
         driverClass=pro.getProperty("driver");
         url = pro.getProperty("url");
         username = pro.getProperty("username");
         password = pro.getProperty("password");
    }

    public static Connection getConnection(){
        return con;
    }
}

BeanHandler与BeanListHandler查询

  • BeanHandler:将结果聚焦第一条记下封装到八个钦定的javaBean

public class Demo {

    public void method(){
        try {

            // 获取QueryRunner对象
            QueryRunner qr = new QueryRunner();

            // 执行SQL语句
            String sql = "SELECT * FROM goods WHERE price>?";

            Object[] params = {2000};
            Connection conn = JDBCUtils.getConnection();
            Goods goods = qr.query(conn, sql, new BeanHandler<Goods>(Goods.class), params);

            // 结果集的处理
            System.out.println( goods );

            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  • BeanListHandler:将结果聚集每一条记下封装到钦点的javaBean中,将这些javaBean在封装到List集合中

public class Demo {

    public void method(){
        try {

            // 获取QueryRunner对象
            QueryRunner qr = new QueryRunner();

            // 执行SQL语句
            String sql = "SELECT * FROM goods WHERE price>?";

            Object[] params = {2000};
            Connection conn = JDBCUtils.getConnection();
            List<Goods> list = qr.query(conn, sql, new BeanListHandler<Goods>(Goods.class), params);

            // 结果集的处理
            for (Goods gs : list) {
                System.out.println(gs);
            }

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

ColumnListHandler与ScalarHandler查询

  • ColumnListHandler:将结果聚集钦命的列的字段值,封装到三个List集合中

public class Demo {

    public void method(){
        try {

            // 获取QueryRunner对象
            QueryRunner qr = new QueryRunner();

            // 执行SQL语句
            String sql = "SELECT name FROM goods WHERE price>?";

            Object[] params = {2000};
            Connection conn = JDBCUtils.getConnection();
            List<String> list = qr.query(conn, sql, new BeanListHandler<String>(), params);

            // 结果集的处理
            for (String str : list) {
                System.out.println(str);
            }

            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  • ScalarHandler:它是用于单数据,比如select count(*) from 表操作

public class Demo {

    public void method(){
        try {

            // 获取QueryRunner对象
            QueryRunner qr = new QueryRunner();

            // 执行SQL语句
            String sql = "SELECT MAX(money) FROM goods";

            Object[] params = {};
            Connection conn = JDBCUtils.getConnection();
            Double max = qr.query(conn, sql, new ScalarHandler<Double>(), params);

            // 结果集的处理
            System.out.println("max=" + max);

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

连接池

实则支出中“获得一连”或“释放财富”是非常消耗系统财富的七个经过,为了解决此类品质难点,平时意况大家利用连接池本事,来分享连接Connection。那样我们就无需每一回都创制连接、释放连接了,那么些操作都付出了连接池

连接池概述

用池来治本Connection,那样能够重复使用Connection。有了池,所以大家就不用本人来创建Connection,而是通过池来收获Connection对象。当使用完Connection后,调用Connection的close()方法也不会真的关闭Connection,而是把Connection“归还”给池。池就能够再接纳那个Connection对象了

连接池规范

Java为数据库连接池提供了集体的接口:javax.sql.DataSource,各类厂家要求让投机的连接池完结这么些接口。这样应用程序能够平价的切换分裂厂商的连接池

周围的连接池:DBCP、C3P0

DBCP连接池

DBCP也是一个开源的连接池,是Apache
Common成员之一,在店堂费用中也正如常见,tomcat内置的连接池

2.2.1导入jar包

奥门威尼斯网址 2

image.png

编写工具类

    public static final String DRIVER = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/daydb";
    public static final String USERNAME = "root";
    public static final String PASSWORD = "123456";
    /*
     * 创建连接池BasicDataSource
     */
    public static BasicDataSource dataSource = new BasicDataSource();
    //静态代码块
    static {
        //对连接池对象 进行基本的配置
        dataSource.setDriverClassName(DRIVER); // 这是要连接的数据库的驱动
        dataSource.setUrl(URL); //指定要连接的数据库地址
        dataSource.setUsername(USERNAME); //指定要连接数据的用户名
        dataSource.setPassword(PASSWORD); //指定要连接数据的密码
    }
    /*
     * 返回连接池对象
     */
    public static DataSource getDataSource(){
        return dataSource;
    }
}

上边是付出能够用到的工具类

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

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class DataSourceUtils {

    private static DataSource dataSource = new ComboPooledDataSource();

    private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    // 直接可以获取一个连接池
    public static DataSource getDataSource() {
        return dataSource;
    }

    // 获取连接对象
    public static Connection getConnection() throws SQLException {

        Connection con = tl.get();
        if (con == null) {
            con = dataSource.getConnection();
            tl.set(con);
        }
        return con;
    }

    // 开启事务
    public static void startTransaction() throws SQLException {
        Connection con = getConnection();
        if (con != null) {
            con.setAutoCommit(false);
        }
    }

    // 事务回滚
    public static void rollback() throws SQLException {
        Connection con = getConnection();
        if (con != null) {
            con.rollback();
        }
    }

    // 提交并且 关闭资源及从ThreadLocall中释放
    public static void commitAndRelease() throws SQLException {
        Connection con = getConnection();
        if (con != null) {
            con.commit(); // 事务提交
            con.close();// 关闭资源
            tl.remove();// 从线程绑定中移除
        }
    }

    // 关闭资源方法
    public static void closeConnection() throws SQLException {
        Connection con = getConnection();
        if (con != null) {
            con.close();
        }
    }

    public static void closeStatement(Statement st) throws SQLException {
        if (st != null) {
            st.close();
        }
    }

    public static void closeResultSet(ResultSet rs) throws SQLException {
        if (rs != null) {
            rs.close();
        }
    }
}

在当前目录下安顿c3p0-config.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <default-config>
        <property name="user">root</property>
        <property name="password">123456</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///jdbc</property>
    </default-config> 
</c3p0-config> 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图