1. 开篇简述

嗨，大家好！！！
在熬过了，有差不多一周多吧，小编最近不知道分享点什么好，这两天，琢磨琢磨，就想给大家分享一下，关于数据库怎么连接上我们的java代码的。说直白点，就是我们怎么用java代码来对数据库进行操作。这里，在我的这个账号里边应该会有JDBC的连接，大家可以下载，不过这个需要钱，当然，小编也给大家提供了白嫖的方法：关注：旺哥学习便利店，回复“MySQL数据库5.0版本”，你就会白嫖成功了。

2. 驱动导包

你想要在java里边，使用MySQL数据库，你就必须先导入对应数据库的jar包，这里小编以MySQL5.5版本为例。
首先，我们需要创建一个文件夹，按照下图即可

其次，就是我们需要把我们导入的jar包，加入到我们的项目中

这样，我们就完成了，开始的第一步。

3. 注意事项

为什么，这里特别的把这个注意事项拿出来呢，因为我把加到第二部分末尾，大家可能不太能注意到，但是这个有很重要，它关乎到你，能不能成功完成第一步，下边大家注意看了：
你导入的一定是jar，不是zip的压缩包。如果你导入的是zip的压缩包，你就找不到Add as library这个选项。
一定注意！一定注意！一定注意！

4. 代码实现

这里给大家一个，JDBC连接的一个工具类吧。是我对连接数据库连接做了一个工具类，以后直接调用方法就行。

public class JdbcUtils {
    //可以把几个字符串定义成常量：用户名，密码，URL，驱动类
    private static final String USER = "root";
    private static final String PWD = "root";
    private static final String URL = "jdbc:mysql://localhost:3306/db3";
    private static final String DRIVER = "com.mysql.jdbc.Driver";

    /**
     * 驱动的注册
     */
    static {
        try {
            Class.forName("DRIVER");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 得到数据库的连接
     * @return : 返回数据库的连接
     * @throws SQLException : SQL的异常
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL,USER,PWD);
    }

    /**
     * 关闭所有打开的资源
     * @param connection : 连接的对象
     * @param statement : 执行SQL语句的对象
     * @throws SQLException
     */
    public static void close(Connection connection,Statement statement) throws SQLException {
        try {
            assert statement != null;
            statement.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }

        try {
            assert connection != null;
            connection.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void close(Connection connection,Statement statement,ResultSet resultSet) throws SQLException {
        try {
            assert statement != null;
            statement.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }

        try {
            assert resultSet != null;
            resultSet.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }

        try {
            assert connection != null;
            connection.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

5. 总结

这里给大家总结一个，这就是一个工具类的书写，并没有mian()函数的执行，因为，哪一个实例来讲，这篇文章就太反锁了。再总结一下代码中的问题吧。

1. 我使用了static代码块，这是是类再加载的时候，这里边的代码就会被执行。建议使用这样的写法
2. 使用了assent 断言，这里的意思是，入伙这个连接对象不为空，就可以执行下边的代码，如果为空，就报异常，到catch中。
3. 这里有一个不足就是关闭有点繁琐，可以简化以下，就是把三个参数的释放，放在两个参数的方法体内，不过这样的化，resultSet就不能使用断言了，可以换做if语句实现。
4. 上边说的三个参数的方法，放在两个参数的方法体内，被调用，这里，我们只需要把resultSet的参数传递为null就可以了，这也是为什么，我们需要把assert断言改为if语句的原因。

一、JDBC数据库连接池的必要性

1、在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：

（1）在主程序（如servlet、beans）中建立数据库连接
（2）进行sql操作
（3）断开数据库连接

2、这种模式开发，存在的问题:

（1）普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
（2）对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。（回忆：何为Java的内存泄漏？）
（3）这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

二、数据库连接池技术

为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。

1、数据库连接池的基本思想：
就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

2、数据库连接池的工作原理：

3、数据库连接池技术的优点：

（1）资源重用
由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。

（2）更快的系统反应速度
数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间

（3）新的资源分配手段
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源

（4）统一的连接管理，避免数据库连接泄漏
在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

三、多种开源的数据库连接池

1、JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：

（1）DBCP 是Apache提供的数据库连接池。tomcat服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。

（2）C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以，hibernate官方推荐使用。

（3）Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点.

（4）BoneCP 是一个开源组织提供的数据库连接池，速度快。

（5）Druid 是阿里提供的数据库连接池，据说是集DBCP 、C3P0 、Proxool优点于一身的数据库连接池，但是速度不确定是否有BoneCP快。

2、DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池

3、DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。

特别注意：

（1）数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
（2）当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close();
但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

3.1 C3P0数据库连接池

（1）获取连接的方式一：

//使用C3P0数据库连接池的方式，获取数据库的连接：不推荐
public static Connection getConnection1() throws Exception{
	ComboPooledDataSource cpds = new ComboPooledDataSource();
	cpds.setDriverClass("com.mysql.jdbc.Driver"); 
	cpds.setJdbcUrl("jdbc:mysql://localhost:3306/test");
	cpds.setUser("root");
	cpds.setPassword("abc123");
		
//	cpds.setMaxPoolSize(100);
	
	Connection conn = cpds.getConnection();
	return conn;
}

（2）获取连接的方式二：

//使用C3P0数据库连接池的配置文件方式，获取数据库的连接：推荐
private static DataSource cpds = new ComboPooledDataSource("helloc3p0");
public static Connection getConnection2() throws SQLException{
	Connection conn = cpds.getConnection();
	return conn;
}

其中，src下的配置文件为：（c3p0-config.xml）

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<named-config name="helloc3p0">
		<!-- 获取连接的4个基本信息 -->
		<property name="user">root</property>
		<property name="password">abc123</property>
		<property name="jdbcUrl">jdbc:mysql:///test</property>
		<property name="driverClass">com.mysql.jdbc.Driver</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>

3.2 DBCP数据库连接池

1、DBCP 是 Apache 软件基金组织下的开源连接池实现，该连接池依赖该组织下的另一个开源系统：Common-pool。如需使用该连接池实现，应在系统中增加如下两个 jar 文件：

Commons-dbcp.jar：连接池的实现
Commons-pool.jar：连接池实现的依赖库

2、Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

3、数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。

4、当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但上面的代码并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

配置属性说明：

（1）获取连接方式一：

public static Connection getConnection3() throws Exception {
	BasicDataSource source = new BasicDataSource();
		
	source.setDriverClassName("com.mysql.jdbc.Driver");
	source.setUrl("jdbc:mysql:///test");
	source.setUsername("root");
	source.setPassword("abc123");
		
	//
	source.setInitialSize(10);
		
	Connection conn = source.getConnection();
	return conn;
}

（2）获取连接方式二：

//使用dbcp数据库连接池的配置文件方式，获取数据库的连接：推荐
private static DataSource source = null;
static{
	try {
		Properties pros = new Properties();
		
		InputStream is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
			
		pros.load(is);
		//根据提供的BasicDataSourceFactory创建对应的DataSource对象
		source = BasicDataSourceFactory.createDataSource(pros);
	} catch (Exception e) {
		e.printStackTrace();
	}
		
}
public static Connection getConnection4() throws Exception {
		
	Connection conn = source.getConnection();
	
	return conn;
}

其中，src下的配置文件为：（dbcp.properties）

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true&useServerPrepStmts=false
username=root
password=abc123

initialSize=10
#...

3.3 Druid（德鲁伊）数据库连接池

Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的连接池之一。

import java.sql.Connection;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class TestDruid {
	public static void main(String[] args) throws Exception {
		Properties pro = new Properties();		 pro.load(TestDruid.class.getClassLoader().getResourceAsStream("druid.properties"));
		DataSource ds = DruidDataSourceFactory.createDataSource(pro);
		Connection conn = ds.getConnection();
		System.out.println(conn);
	}
}

其中，src下的配置文件为：（druid.properties）

url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
username=root
password=123456
driverClassName=com.mysql.jdbc.Driver

initialSize=10
maxActive=20
maxWait=1000
filters=wall

详细参数配置：

前言

JDBC即Java DataBase Connectivity，java数据库连接；JDBC 提供的API可以让JAVA通过API方式访问关系型数据库，执行SQL语句，获取数据；常见关系型数据库如Oracle、MySQL、SQLServer等；对于非关系型数据库如Redis、mongonDB等就显得无力；关系型数据库最典型的数据结构是表，易于维护，灵活使用(使用表结构，支持SQL语言的简单及复杂表及多表之间的查询)，非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方法的集合(文档型、键值对型、列式数据库、图形数据库)，相对于关系型数据库(读写性能比较差，效率低，灵活度低、高并发处理显得鸡肋)；非关系型数据库优点多多，速度快、高拓展、低成本(就数据结构复杂，其他都比较简单，学习难度就有点大)。
言归正传，从根本来讲，JDBC是一种规范，它提供的接口，是一套完整的、可移植的访问底层数据库的程序。

JDBC驱动结构模型

分两种架构模型：三层和两层；下面是三层软件架构的模型，分别是表示层UI、业务逻辑层BLL、数据访问层DAL;两层架构的就把表现层UI拿掉。

java中使用JDBC连接数据库

在应用程序中进行数据库连接，调用JDBC接口，首先要将特定厂商的JDBC驱动实现加载到系统内存中，然后在应用程序中就可以直接根据URL和用户密码来识别获取对应的驱动实例，与数据库建立连接，对数据库进行相关操作。

  	//1.加载mysql数据库驱动
  	static String driverName = "com.mysql.jdbc.Driver";
  	//2.加载oracle数据库驱动
  	//static String driverName = "oracle.jdbc.driver.OracleDriver";
  	//3.加载SQL Server数据库驱动
  	//static String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    static String url = "jdbc:mysql://127.0.0.1:3306/mysql";
    static String username = "root";
    static String password = "123456";
    public void getConnection() {
        try {
            // 1.1、加载驱动,使用Class.forName()将驱动类加载到内存
            Class.forName(driverName);
            //1.2或者使用
            //Driver driver = (Driver) Class.forName(driverName).newInstance();
            // 2.1、获取connection
            Connection conn = DriverManager.getConnection(url,username,password);
            //2.2或者使用
           /* Properties info = new Properties();
            info.put("user", username);
            info.put("password", password);
            Connection conn = driver.connect(url, info);
            */
            System.out.println(conn);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

JDBC驱动原理详解

对于已经安装好的数据库之后，我们想要直接使用数据库，比如保存用户数据资料等，要通过该数据库厂商提供的驱动程序才能与数据库交互，其实就是数据库厂商的JDBC接口实现；我们只需使用他们提供的对JDBC接口实现类的jar文件。如Oracle数据库对应使用ojdbc8.jar包等等。不同关系型数据库版本使用的JDBC的jar包都不同。
1.上面加载的JDBC驱动的方法有两种，一种使用DriverManager管理(推荐)，一种直接Driver（耦合太强，不推荐）
1.1 Class.forName(driverName)和Driver driver = (Driver) Class.forName(driverName).newInstance();
因为驱动本质就是一个class，Class.forName()的作用就是将class加载到内存中，而这个driveName其实就是实现了java.sql.Driver（在java.lang.Object包下找到）接口的类(此类可以在数据库厂商提供的JDBC jar包中找到)；当使用Class.forName(driverName)加载驱动类到内存中的时候，同时会执行这个驱动类中的静态代码块，创建一个Driver实例，然后调用DriverManager.registerDriver(Driver实例)进行驱动注册，供后面使用。
下面使用oracle数据库为例来源码分析：
1.1.1在oracle.jdbc.driver包下的OracleDriver驱动类，实现了java.sql.Driver类

1.1.2当使用Class.forName()加载驱动类oracle.jdbc.driver.OracleDriver.class的时候，会执行oracle.jdbc.driver.OracleDriver.class中的静态代码块和java.sql.DriverManager.class中的静态代码块：

//oracle.jdbc.driver.OracleDriver.class中的静态代码块
package oracle.jdbc.driver;

import java.security.AccessController;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import oracle.jdbc.OracleDatabaseMetaData;
import oracle.jdbc.driver.OracleDriver.1;
import oracle.security.pki.OracleSecretStore;
import oracle.security.pki.OracleWallet;
public class OracleDriver implements Driver {
	private static OracleDriver defaultDriver = null;
	private static final String _Copyright_2004_Oracle_All_Rights_Reserved_;
	//省略。。。	
	static {
		Timestamp localTimestamp = Timestamp.valueOf("2000-01-01 00:00:00.0");
		try {
			if (defaultDriver == null) {
			//1.不存在OracleDriver驱动实例就创建该实例--自己加的注释
				defaultDriver = new OracleDriver();
			//2.将Oracle驱动实例进行注册--自己加的注释
				DriverManager.registerDriver(defaultDriver);
			}
		} catch (RuntimeException localRuntimeException) {
			;
		} catch (SQLException localSQLException) {
			;
		}
		_Copyright_2004_Oracle_All_Rights_Reserved_ = null;
	}
}

//	java.sql.DriverManager.class中的静态代码块
package java.sql;

import java.util.Iterator;
import java.util.ServiceLoader;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.concurrent.CopyOnWriteArrayList;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
public class DriverManager {
 // List of registered JDBC drivers
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    private static volatile int loginTimeout = 0;
    private static volatile java.io.PrintWriter logWriter = null;
    private static volatile java.io.PrintStream logStream = null;
    // Used in println() to synchronize logWriter
    private final static  Object logSync = new Object();
/* Prevent the DriverManager class from being instantiated. */
    private DriverManager(){}


    /**
     * Load the initial JDBC drivers by checking the System property
     * jdbc.properties and then use the {@code ServiceLoader} mechanism
     */
    static {
      //加载配置在jdbc.drivers系统变量中的驱动driver--自己的注释
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
  private static void loadInitialDrivers() {
        String drivers;
        try {
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
        // If the driver is packaged as a Service Provider, load it.
        // Get all the drivers through the classloader
        // exposed as a java.sql.Driver.class service.
        // ServiceLoader.load() replaces the sun.misc.Providers()

        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {

                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();

                /* Load these drivers, so that they can be instantiated.
                 * It may be the case that the driver class may not be there
                 * i.e. there may be a packaged driver with the service class
                 * as implementation of java.sql.Driver but the actual class
                 * may be missing. In that case a java.util.ServiceConfigurationError
                 * will be thrown at runtime by the VM trying to locate
                 * and load the service.
                 *
                 * Adding a try catch block to catch those runtime errors
                 * if driver not available in classpath but it's
                 * packaged as service and that service is there in classpath.
                 */
                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }
                return null;
            }
        });

        println("DriverManager.initialize: jdbc.drivers = " + drivers);

        if (drivers == null || drivers.equals("")) {
            return;
        }
        String[] driversList = drivers.split(":");
        println("number of Drivers:" + driversList.length);
        for (String aDriver : driversList) {
            try {
                println("DriverManager.Initialize: loading " + aDriver);
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }
}

当使用Class.forName(driverName)加载驱动类到内存中的时候，同时会执行这个驱动类中的静态代码块，创建一个Driver实例；然后调用DriverManager 进行注册Driver；DriverManager 作为 Driver 的管理器，它在第一次被调用的时候，它会被加载到内存中，然后执行其定义的static静态代码段，在静态代码段中，有一个 loadInitialDrivers() 静态方法，用于加载配置在jdbc.drivers 系统属性内的驱动Driver，配置在jdbc.drivers 中的驱动driver将会首先被加载上面的静态代码块使用的是DriverManager来统一管理操作Driver和获取Connection对象；DriverManager驱动管理类方便管理存在多个Driver驱动实例的情况；可以进行注册和删除加载的驱动程序，可以根据给定的Url获取符合url协议的驱动Driver并建立Connection连接，进行数据交互。
java.sql.DriverManager类的方法摘要：
DriverManager.registerDriver(Driver driver)的参数是一个java.sql.Driver接口的实现类实例对象，
java.sql.Driver接口的方法摘要有：
1.2使用DriverManager获取Connection时，使用DriverManager提供的getConnection()方法，该方法会自动根据url匹配对应的驱动Driver实例，然后调用Driver实例实现java.sql.Driver接口方法connect()获取对应的URL的数据库连接，返回Connection对象实例；如果不使用DriverManager可以直接Driver实例调用java.sql.Driver接口的connect(String url,Properties info)方法获取连接。如上面代码两者是等价的

			//加载JDBC驱动
            Class.forName(driverName);
            //获取数据库连接
            Connection conn = DriverManager.getConnection(url,username,password);

跟下面是一样的效果：

	//获取JDBC驱动
	Driver driver = (Driver) Class.forName(driverName).newInstance();
	//或者Driver driver  = DriverManager.getDriver(url);
	Properties info = new Properties();
	info.put("user", username);
	info.put("password", password);
	//获取数据库链接
	Connection conn = driver.connect(url, info);

1.3获取数据库时的认证
利用Driver的接口方法acceptsURL(String url) ，该方法只会校验url是否符合协议和是否能打开该url连接，每个数据库厂商都会制定自己的url协议，只有符合自己的协议形式的url才认为自己能够打开这个url；但不会判断url是否有效。
例如oracle定义的自己的url协议如下：
jdbc:oracle:thin:@//:/ServiceName
jdbc:oracle:thin:@::
oracle的acceptsURL(String url)方法源码如下：

package oracle.jdbc.driver;

import java.security.AccessController;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import oracle.jdbc.OracleDatabaseMetaData;
import oracle.jdbc.driver.OracleDriver.1;
import oracle.security.pki.OracleSecretStore;
import oracle.security.pki.OracleWallet;
public class OracleDriver implements Driver {
//省略。。。
	public boolean acceptsURL(String var1) {
		if (var1.startsWith("jdbc:oracle:")) {
			return this.oracleDriverExtensionTypeFromURL(var1) > -2;
		} else {
			return false;
		}
	}
	private int oracleDriverExtensionTypeFromURL(String var1) {
		int var2 = var1.indexOf(58) + 1;
		if (var2 == 0) {
			return -2;
		} else {
			int var3 = var1.indexOf(58, var2);
			if (var3 == -1) {
				return -2;
			} else if (!var1.regionMatches(true, var2, "oracle", 0, var3 - var2)) {
				return -2;
			} else {
				++var3;
				int var4 = var1.indexOf(58, var3);
				if (var4 == -1) {
					return -3;
				} else {
					String var5 = var1.substring(var3, var4);
					if (var5.equals("thin")) {
						return 0;
					} else {
						return !var5.equals("oci8") && !var5.equals("oci") ? -3 : 2;
					}
				}
			}
		}
	}
}