Java_JDBC 连接

　　今天，接着上一篇（ mysql 数据库 ）的基础上，我就写一下 java 怎样连接数据库，并且操作数据库。

　　首先，我们先来准备一下数据库连接的驱动：

　　mysql 的 jar 包下载地址：

　　oracle 的 jar 包下载地址：https://www.oracle.com/technetwork/cn/middleware/goldengate/downloads/index.html

　　本文章还用到 c3p0 的数据库连接池

　　c3p0 的 jar 包下载地址：

　　接下来，我们就开始正式了解一下什么是 jdbc ，用 java 怎样连接数据库，并且怎样操作数据库。

什么是jdbc

　　jdbc（java database connectivity,java数据库连接）是一种用于执行sql语句的java api，可以为多种关系数据库提供统一访问，它由一组用java语言编写的类和接口组成。jdbc提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。

数据库驱动

　　我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程序去和数据库打交道。其实也就是数据库厂商的jdbc接口实现，即对connection等接口的实现类的jar文件。

driver接口

　　driver接口由数据库厂家提供，作为java开发人员，只需要使用driver接口就可以了。在编程中要连接数据库，必须先装载特定厂商的数据库驱动程序，不同的数据库有不同的装载方法。如：

　　装载mysql驱动：class.forname("com.mysql.jdbc.driver");

　　装载oracle驱动：class.forname("oracle.jdbc.driver.oracledriver");

connection接口

　　connection与特定数据库的连接（会话），在连接上下文中执行sql语句并返回结果。drivermanager.getconnection(url, user, password)方法建立在jdbc url中定义的数据库connection连接上。

　　连接mysql数据库：connection conn = drivermanager.getconnection("jdbc:mysql://host:port/database", "user", "password");

　　连接oracle数据库：connection conn = drivermanager.getconnection("jdbc:oracle:thin:@host:port:database", "user", "password");

　　连接sqlserver数据库：connection conn = drivermanager.getconnection("jdbc:microsoft:sqlserver://host:port; databasename=database", "user", "password");

　　常用方法：

• • createstatement()：创建向数据库发送sql的statement对象。
  • preparestatement(sql) ：创建向数据库发送预编译sql的preparesatement对象。
  • preparecall(sql)：创建执行存储过程的callablestatement对象。
  • setautocommit(boolean autocommit)：设置事务是否自动提交。
  • commit() ：在链接上提交事务。
  • rollback() ：在此链接上回滚事务。

 

使用jdbc的步骤

　　加载jdbc驱动程序 → 建立数据库连接connection → 创建执行sql的语句statement → 处理执行结果resultset → 释放资源

初始化驱动

　　通过初始化驱动类com.mysql.jdbc.driver，该类就在 mysql-connector-java-5.0.8-bin.jar中。如果你使用的是oracle数据库那么该驱动类将不同。

 

//加载数据库驱动程序(对应的 driver 实现类中有注册驱动的静态代码块.)
string driver ="com.mysql.jdbc.driver";
class.forname(driver);

 

建立jdbc和数据库之间的connection连接

//通过 drivermanager 的 getconnection() 方法获取数据库连接.
connection conn = drivermanager.getconnection(url,user,password);

这里需要提供：url包括以下（jdbc:mysql://ip地址:端口号/需要连接的数据库名字），例如：jdbc:mysql://localhost:3306/db_database05

　　　　　　　数据库所处于的ip:127.0.0.1 (这里是本机，如果连接其他电脑上的数据库，请改变该ip)
                         数据库的端口号： 3306 （mysql专用端口号）
                         数据库名称： （根据你自己数据库中的名称填写）

　　　　　　　数据库连接的用户名：user

　　　　　　　数据库的登录密码：password

创建数据库连接的工具方法

/*
 * 数据库连接工具类
 */
package com.hzc.util;

import java.sql.connection;
import java.sql.drivermanager;

public class databaseutil {
    /**
     * 获取数据库连接
     * @return connection 对象
     */
    public static connection getconnection(){
        connection conn = null;
        try {
            class.forname("com.mysql.jdbc.driver");
            string url = "jdbc:mysql://localhost:3306/db_database05";
            conn = drivermanager.getconnection(url,user,password);　　　　//这里的user和password根据自己的数据库登录和密码填写
        } catch (exception e) {
            e.printstacktrace();
        }
        return conn;
    }
    /**
     * 关闭数据库连接
     * @param conn connection 对象
     */
    public static void closeconnection(connection conn){
        //判断 conn 是否为空
        if(conn != null){
            try {
                conn.close();            //关闭数据库连接
            } catch (exception e) {
                e.printstacktrace();
            }
        }
    }
}

 

　　这里在提供 c3p0 数据库连接池的方法

c3p0 数据库连接池

package jdbc;

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;

/*
 * 操作jdbc的工具类，其中封装了一些工具方法
 */
public class jdbctools {
    
    private static datasource datasource = null;
    //数据库连接池应只初始化一次
    static{
        datasource = new combopooleddatasource("helloc3p0");
    }

    //数据库连接：通过读取配置文件从数据库服务器获取一个连接
    public static connection getconnection() throws exception{
        
        return datasource.getconnection();
    }
    
    //关闭 resultset、statement 和 connection
    public static void release(resultset rs,statement statement,connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (sqlexception e) {
                e.printstacktrace();
            }
        }
        if(statement != null){
            try {
                statement.close();
            } catch (sqlexception e) {
                e.printstacktrace();
            }
        }
        //数据库连接池的 connection 对象进行 close 时
        //并不是真的进行关闭, 而是把该数据库连接会归还到数据库连接池中.
        if(conn != null){
            try {
                conn.close();
            } catch (sqlexception e) {
                e.printstacktrace();
            }
        }
    }
    
    /*
     * 处理数据库的事务
     */
    
    //提交事务
    public static void commit(connection conn){
        if(conn != null){
            try {
                conn.commit();
            } catch (sqlexception e) {
                e.printstacktrace();
            }
        }
    }
    
    //回滚事务
    public static void rollback(connection conn){
        if(conn != null){
            try {
                conn.rollback();
            } catch (sqlexception e) {
                e.printstacktrace();
            }
        }
    }
    
    //开始事务
    public static void begintx(connection conn){
        if(conn != null){
            try {
                conn.setautocommit(false);
            } catch (sqlexception e) {
                e.printstacktrace();
            }
        }
    }
}

　　c3p0 要在 src 目录下配置：创建一个名为 c3p0-config.xml ，并且记住要导入 c3p0 的 jar 包。

c3p0-config.xml 的配置

<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>

    <named-config name="helloc3p0">
        
        <!-- 指定连接数据源的基本属性 -->
        <property name="user">登录名</property>
        <property name="password">密码</property>
        <property name="driverclass">com.mysql.jdbc.driver</property>
        <property name="jdbcurl">jdbc:mysql://localhost:3306/test</property>
        
        <!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
        <property name="acquireincrement">5</property>
        <!-- 初始化数据库连接池时连接的数量 -->
        <property name="initialpoolsize">5</property>
        <!-- 数据库连接池中的最小的数据库连接数 -->
        <property name="minpoolsize">5</property>
        <!-- 数据库连接池中的最大的数据库连接数 -->
        <property name="maxpoolsize">10</property>

        <!-- c3p0 数据库连接池可以维护的 statement 的个数 -->
        <property name="maxstatements">20</property>
        <!-- 每个连接同时可以使用的 statement 对象的个数 -->
        <property name="maxstatementsperconnection">5</property>
    
    </named-config>
        
</c3p0-config>

statement接口

　　用于执行静态sql语句并返回它所生成结果的对象。

　　三种statement类：

• • statement：由createstatement创建，用于发送简单的sql语句（不带参数）。
  • preparedstatement ：继承自statement接口，由preparedstatement创建，用于发送含有一个或多个参数的sql语句。preparedstatement对象比statement对象的效率更高，并且可以防止sql注入，所以我们一般都使用preparedstatement。
  • callablestatement：继承自preparedstatement接口，由方法preparecall创建，用于调用存储过程。

　　常用statement方法：

• • execute(string sql):运行语句，返回是否有结果集
  • executequery(string sql)：运行select语句，返回resultset结果集。
  • executeupdate(string sql)：运行insert/update/delete操作，返回更新的行数。
  • addbatch(string sql) ：把多条sql语句放到一个批处理中。
  • executebatch()：向数据库发送一批sql语句执行。

 

resultset接口

　　resultset提供检索不同类型字段的方法，常用的有：

 

• • getstring(int index)、getstring(string columnname)：获得在数据库里是varchar、char等类型的数据对象。
  • getfloat(int index)、getfloat(string columnname)：获得在数据库里是float类型的数据对象。
  • getdate(int index)、getdate(string columnname)：获得在数据库里是date类型的数据。
  • getboolean(int index)、getboolean(string columnname)：获得在数据库里是boolean类型的数据。
  • getobject(int index)、getobject(string columnname)：获取在数据库里任意类型的数据。

 

　　resultset还提供了对结果集进行滚动的方法：

 

• • next()：移动到下一行
  • previous()：移动到前一行
  • absolute(int row)：移动到指定行
  • beforefirst()：移动resultset的最前面。
  • afterlast() ：移动到resultset的最后面。

 

使用后依次关闭对象及连接：resultset → statement → connection

　　这里就直接提供数据库通用的查询方法，自己写成一个公用类，需要用查询方法的时候，就可以继承它，调用里面的方法。

jdbc 的 dao 方法

package jdbc;

/*
 * jdbc的工具方法
 */
import java.sql.connection;
import java.sql.preparedstatement;
import java.sql.resultset;
import java.sql.resultsetmetadata;
import java.sql.sqlexception;
import java.sql.statement;
import java.util.arraylist;
import java.util.hashmap;
import java.util.list;
import java.util.map;
import org.apache.commons.beanutils.beanutils;

public class dao {

    // 执行 sql 语句,使用 preparedstatement
    public void update(string sql, object... args) {
        connection conn = null;
        preparedstatement ps = null;
        try {
            conn = jdbctools.getconnection();
            ps = conn.preparestatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setobject(i + 1, args[i]);
            }
            ps.executeupdate();
        } catch (exception e) {
            e.printstacktrace();
        } finally {
            jdbctools.release(null, ps, conn);
        }
    }

    // 执行sql的方法,使用 statement：insert、update、delete,而不包含select
    public void update(string sql) {
        connection conn = null;
        statement st = null;
        try {
            conn = jdbctools.getconnection();
            st = conn.createstatement();
            st.executeupdate(sql);
        } catch (exception e) {
            e.printstacktrace();
        } finally {
            jdbctools.release(null, st, conn);
        }
    }

    // 查询一条记录,返回对应的对象
    public <t> t get(class<t> clazz, string sql, object... args)throws exception {
        list<t> result = getforlist(clazz, sql, args);
        if (result.size() > 0) {
            return result.get(0);
        }
        return null;
    }

    /*
     * 传入 sql 语句和 class 对象,返回 sql 语句查询的记录对应的 class 类的对象的集合
     * 
     * @param clazz: 对象的类型
     * 
     * @param sql: sql 语句
     * 
     * @param args: 填充 sql 语句的占位符的可变参数
     * 
     * @return
     */
    public <t> list<t> getforlist(class<t> clazz, string sql, object... args)throws exception {
        list<t> list = new arraylist<>();
        connection conn = null;
        preparedstatement ps = null;
        resultset rs = null;
        try {
            // 1、得到结果集
            conn = jdbctools.getconnection();
            ps = conn.preparestatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setobject(i + 1, args[i]);
            }
            rs = ps.executequery();

            // 2、处理结果集，得到 map 的 list, 其中一个 map 对象就是一条记录. map 的 key 为 rs 中列的别名,
            // map 的 value 为列的值
            list<map<string, object>> values = handleresultsettomaplist(rs);

            // 3、把 map 的 list 转为 clazz 对应的 list, 其中 map 的 key 即为 clazz 对应的对象的
            // propertyname,
            // 而 map 的 value 即为 clazz 对应的对象的 propertyvalue
            list = transftermaplisttobeanlist(clazz, values);

        } catch (exception e) {
            e.printstacktrace();
        } finally {
            jdbctools.release(rs, ps, conn);
        }

        return list;
    }

    // 把 map 的 list 转为 clazz 对应的 list
    public <t> list<t> transftermaplisttobeanlist(class<t> clazz, list<map<string, object>> values)throws exception {
        list<t> result = new arraylist<>();
        t bean = null;
        if (values.size() > 0) {
            for (map<string, object> m : values) {
                bean = clazz.newinstance();
                for (map.entry<string, object> entry : m.entryset()) {
                    string propertyname = entry.getkey();
                    object value = entry.getvalue();

                    beanutils.setproperty(bean, propertyname, value);
                }
                // 把 object 对象放入到 list 中
                result.add(bean);
            }
        }
        return result;
    }

    /**
     * 处理结果集, 得到 map 的一个 list, 其中一个 map 对象对应一条记
     * 
     * @param resultset
     * @return
     * @throws sqlexception
     */
    public list<map<string, object>> handleresultsettomaplist(resultset rs) throws exception {
        // 准备一个 list<map<string, object>>:键: 存放列的别名, 值: 存放列的值. 其中一个 map
        // 对象对应着一条记录
        list<map<string, object>> values = new arraylist<>();
        list<string> columnlabels = getcolumnlabels(rs);
        map<string, object> map = null;

        // 处理 resultset, 使用 while 循环
        while (rs.next()) {
            map = new hashmap<>();
            for (string columnlabel : columnlabels) {
                object value = rs.getobject(columnlabel);
                map.put(columnlabel, value);
            }

            // 把一条记录的一个 map 对象放入 list 中
            values.add(map);
        }
        return values;
    }

    /**
     * 获取结果集的 columnlabel 对应的 list
     * 
     * @param rs
     * @return
     * @throws sqlexception
     */
    private list<string> getcolumnlabels(resultset rs) throws exception {
        list<string> labels = new arraylist<>();
        resultsetmetadata rsmd = rs.getmetadata();
        for (int i = 0; i < rsmd.getcolumncount(); i++) {
            labels.add(rsmd.getcolumnlabel(i + 1));
        }
        return labels;
    }

    // 返回某条记录的某一个字段的值 或 一个统计的值(一共有多少条记录等.)
    @suppresswarnings("unchecked")
    public <e> e getforvalue(string sql, object... args) {
        // 1. 得到结果集: 该结果集应该只有一行, 且只有一列
        connection conn = null;
        preparedstatement ps = null;
        resultset rs = null;
        try {
            // 1. 得到结果集
            conn = jdbctools.getconnection();
            ps = conn.preparestatement(sql);

            for (int i = 0; i < args.length; i++) {
                ps.setobject(i + 1, args[i]);
            }

            rs = ps.executequery();

            if (rs.next()) {
                return (e) rs.getobject(1);
            }
        } catch (exception ex) {
            ex.printstacktrace();
        } finally {
            jdbctools.release(rs, ps, conn);
        }
        // 2. 取得结果

        return null;
    }
}

　　掌握好 jdbc 的连接，java 写很多项目都要与数据库打交道。

　　自己写的不是专业，希望大家提一下意见。自己也是在学习 java 的小白。写一下博客记录一下自己的学习情况。写一下博客，能了解自己学习的水平。