目录
 
文中储备知识：
 
1.JDBC
 
2.两种常见的JDBC
 
      （1）JDBC-ODBC桥方式
 
      （2）纯Java方式
 
3.DSN
 
4.JDBC操作的步骤
 
 
 
一、JDBC配置问题
 
1.JDBC-ODBC桥方式
 
2.纯Java方式
 
二、名字不匹配
 
（1）数据库名
 
（2）数据库对应的用户名
 
（3）表名
 
（4）表名中的属性名
 
         （5）与ODBC方法相关的数据源名
 
三、数据库连接代码
 

文中储备知识：
 
1.JDBC
 
 
 
JDBC是Java数据连接技术(Java Database Connection)的简称，提供连接各种常用数据库的能力。
 
 

  •JDBC驱动由数据库厂商提供
 
 
 

  –在个人开发与测试中，可以使用JDBC-ODBC桥连方式
 
 
 

  –在生产型开发中，推荐使用纯Java驱动方式
 
 
 
2.两种常见的JDBC
 
（1）JDBC-ODBC桥方式
 
 
 
使用JDBC-ODBC桥方式连接数据库
 
 

  –
  将对
  JDBC API
  的调用，转换为对另一组数据库连接
  API
  的调用
 
 
 

  –
  优点：可以访问所有
  ODBC
  可以访问的数据库
 
 
 

  –
  缺点：执行效率低、功能不够强大
 
 
 
（2）纯Java方式
 
 
 
使用纯Java方式连接数据库 
 
 

  –
  由
  JDBC
  驱动直接访问数据库
 
 
 

  –
  优点：
  100% Java
  ，快又可跨平台
 
 
 

  –
  缺点：访问不同的数据库需要下载专用的
  JDBC
  驱动
 
 
 
但是，经过实践操作，大多数同学都觉得纯Java方式连接数据库的成功率更高些，使用JDBC-ODBC桥常连接失败（不知道是不是操作流程的问题）。
 
3.DSN
 
 
 
数据源的定义：
 
数据源的英文是DSN(Data Source Name)，它是一种用来提高数据库连接性能的常规手段。
 
 
数据源的作用：
 
“数据库建立好之后，要设定系统的 DSN（数据来源名称），才能让网页可以知道数据库所在的位置以及数据库相关的属性。使用DSN的好处还有，如果移动数据库档案的位置，或是换成别种类型的数据库，只要重新设定 DSN 就好了，不需要去修改原来使用的程序。”
 
 
4.JDBC操作的步骤：
 
  1、 加载驱动程序
   2、 连接数据库
   3、 操作数据库
   4、 关闭数据库，释放连接
 
参考资料：
 
https://blog.csdn.net/lxw1844912514/article/details/100028770
 
https://www.cnblogs.com/cainame/p/10339294.html
 
https://blog.csdn.net/cuiwjava/article/details/20202859
 

一、JDBC配置问题
 
1.JDBC-ODBC桥方式
 
（1）配置ODBC桥的流程中出问题
 
A.数据源（DSN）配置
 
在电脑中的 “控制面板——系统和安全——管理工具——数据源（ODBC）” 中配置ODBC桥的数据源
 
注1：数据源的英文DSN(Data Source Name)
注2：配置过程中的DSN名称需要记住，用于后面用Java写数据库连接代码中的创建连接（）
private Connection conn; 
 
conn=DriverManager.getConnection("jdbc:odbc:DSN名称","用户名","密码");
 
a. 没有选择与代码中相匹配的用户登录ID和密码
因为在配置数据源的过程中，需要在
 
“用户输入登录ID和密码的SQL Server 验证”下
 
输入在数据库创建的用户及其对应密码
 
b. 没有选择与代码中相匹配的数据库
因为在配置数据源的过程中，需要选择该用户操作的数据库
 
数据源的配置过程可参考：
 
https://blog.csdn.net/qq_41187714/article/details/103494367
 
 
 
2.纯Java方式
 
（1）JDBC驱动包与数据库不匹配
 
比如 Microsoft SQL Server 2008 R2数据库可以下载sqljdbc4驱动包
 
（2）添加驱动包的方法不正确
 
可以右键项目名——Build Path——Config Build Path...——Java Build Path ——Libraries——Add JARs或AddExternal JARS——OK
 
（3）驱动包路径不对
 
常见于拷贝了别人的项目到自己的电脑里
 
修改驱动包路径的方法：在项目中重新加载驱动包，即可以重新添加驱动包
 
添加jar包方法可参考：
https://www.cnblogs.com/yhmdjl/p/6485303.html
 
注：
 
JAR（Java Archive）是Java的一种压缩文档格式
 
 
 
二、名字不匹配
 
主要是数据库中的设置与代码中的不匹配
 
（1）数据库名
 
（2）数据库对应的用户名
 
（3）表名
 
比如 数据库中的表名是tblXyInfo，而 Java代码中写的是却是tblXyxx
 
（4）表名中的属性名
 
比如 数据库中的学院信息表 tblXyInfo 中有代码XyId、名称XyName、状态XyState、添加时间XyTime这几个属性。
 
注意：
 
（1）大小写的区分
 
（2）“同义词”
 
比如：学院信息表
 
tblXyInfo ——table xue yuan information
 
tblXyxx ——table xue yuan xin xi
 
（5）与ODBC方法相关的数据源名
 
 
 
三、数据库连接代码
 
除了编译中报的语法错误外，还可能存在如下问题：
 
1.没有实例化对象
 
常会编写一个xxxHelper.java 然后再实例化这个类的对象。
  
 
private OdbcHelper helper;//在类中定义成员

//private MssHelper helper;



helper = new OdbcHelper();//在类的方法中实例化这个成员
//helper = new MssHelper();
 
注：
 
OdbcHelper.java中存放 ODBC桥连接数据库的代码。（需配置数据源）
 
MssHelper.java中存放 直连数据库的代码。（需加载驱动包）
 
 
 
本篇文章将会持续更新....
 
 
 
 

    最近在写一个Java小项目，用到了数据库连接的知识，一个多星期的使用也碰到了不少问题。这里把这一块总结一下。
 
   本人使用的是eclipse编译器和MySQL数据库还有连接两个的数据库驱动。配置的话可以看我的另一篇连接：配置驱动
 
   接下来就是正常的链接操作了。Java语言和数据库的连接直接有相应的实现，之后对于数据库的操作语句也是直接使用字符串的形式通过类的使用来完成，主要的又一下几步：
 
public class damen_01 {
 
    // JDBC 驱动名及数据库 URL
    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver"；  
    static final String DB_URL = "jdbc:mysql://localhost:3306/day01";
 
    // 数据库的用户名与密码，需要根据自己的设置
    static final String USER = "root";
    static final String PASS = "";
 
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try{
            // 注册 JDBC 驱动
        	Class.forName(JDBC_DRIVER);
        	
            // 打开链接
            System.out.println("连接数据库...");
            conn = DriverManager.getConnection(DB_URL,USER,PASS);
            if(!conn.isClosed())
            	System.out.println("success");
            // 执行查询
            System.out.println(" 实例化Statement对象...");
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT id, name, url FROM websites";
            ResultSet rs = stmt.executeQuery(sql);
        
            // 展开结果集数据库
            while(rs.next()){
                // 通过字段检索
                int id  = rs.getInt("id");
                String name = rs.getString("name");
                String url = rs.getString("url");
    
                // 输出数据
                System.out.print("ID: " + id);
                System.out.print(", 站点名称: " + name);
                System.out.print(", 站点 URL: " + url);
                System.out.print("\n");
            }
            // 完成后关闭
            rs.close();
            stmt.close();
            conn.close();
        }catch(SQLException se){
            // 处理 JDBC 错误
            se.printStackTrace();
            System.out.println("<<<<<");
        }catch(Exception e){
            // 处理 Class.forName 错误
            e.printStackTrace();
            System.out.println("???????");
        }finally{
            // 关闭资源
            try{
                if(stmt!=null) stmt.close();
            }catch(SQLException se2){
            }// 什么都不做
            try{
                if(conn!=null) conn.close();
            }catch(SQLException se){
                se.printStackTrace();
            }
        }
    }
 
代码是在菜鸟教程上找到的，看着来入门写点东西还是很简单的，这里就我当时的疑惑和出现错误的地方再写点注释：
 
一.注册驱动： 这里的注册驱动中是字符串形式，其中的字符串一般都是固定的，但是最先版的MySQL使用的不是 
          上面的那个，记得中间还需要加上点东西，具体的没记太清楚，不过百度一下很随意都可以搜到。一 
          般这里出错时间都是一下几种：
          1. 驱动版本和MySQL不对照
          
          2. 驱动没配置好
          
          3. 该句中的字符串写错

二.打开连接： 这里主要是三给字符串代表的含义。代表意义如下：
          1.以斜杠为间隔，分别代表使用的驱动的数据库类型，地址以及端口，该数据库中需要访问的数据库 
            名称

          2.登陆的账户名称
        
          3.该账户登陆所需密码

三.执行语句： 这里的MySQL操作命令都是以字符串命令的形式出现的，因此只需要将所需操作的命令传入一个字 
           符串类型的实例化对象即可，同样也可以使用 ‘+’ 符号来连接那些含有变量不确定的语句构成字符 
           串，例如：String sql ="select * from books where b_id='"+id+"'";
           这里的ResultSet所定义的类rs代表的是查询之后返回的数据集合。

四.展开结果：使用rs.next()循环来递归得到相应数据。注意，以上这些使用过之后应该及时关闭，以免出现数 
           据泄露的可能。

五.抛出异常：建议使用try....catch....来处理异常，这样可以直观的看到是何种异常，进而及时的更改
 
大致的情况也就是这样了。接下来是一些常见的错误：
 
   一. 数据库语句出错，这种错误出现时间输出的异常是MySQL语句错误（很容易分辨），需要认真检查。
 
   二. 使用了PreparedStatement 类来替换 Statement类，该类方便了sql命令字符串的构造，但是需要多出预处理的过程，                   可以说有利有弊吧，不够需要清楚知道该类预处理时间的操作。
 
   三.该错误出去sql语句的错误，出现的次数可能是最多的了。是Statement类所对应SQL语句执行时使用的 executeQuery(),
 
        executeUpdate(),execute(）这三种方法，方法是有所区别的，执行select语句时间直接使用第一个即可，但是insert需要使          用第三个，update需要使用第二个。使用不当也是会出现报错。
 
行了，就这些吧，错误常见的目前感觉也就这些，其他的也遇到过，不过记不太清了，以后遇到了再添加吧

1、开发工具 ：
 a)eclipse：开发java程序（配置环境变量方法自行查阅）
 b)mysql数据库：（官网下载，尽量不要下载最新版），注意开启服务，
 开启服务的方法— —右键单击桌面"此电脑"——点击"管理"——按照下图找到MySQL，启动该服务
 
 c)Navicat Premium开发工具（可到官网下载）
 d)mysql连接jar包：如图就是其一版本
 
 2、Navicat Premium使用：
 点击"连接"——“MySQL”——输入密码——点击"连接测试"——连接成功
 
 
 
 连接成功后，新建一个数据库，并新建一个表，以便之后用java连接数据库时调用！
 
3、Eclipse连接MySQL：
 1)eclipse创建一个文件夹lib
 2)复制mysqlconn…jar（mysql连接jar包） 到 lib
 3)项目右键 build path —configure build path—接着如下图所示—Add JARs
 
 4）创建连接，并测试是否连接成功：
 
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/mysql1";//连接数据库mysql1
this.conn=DriverManager.getConnection(url, "root", "123456");
System.out.println(this.conn.isClosed());	//是否连接成功，false 代表成功
 
4、操作数据库（实例）：
 
1）创建DB定制类：
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class DB {

	private Connection conn;
	private Statement stmt;
	
	public DB() {
		try {
			Class.forName("com.mysql.jdbc.Driver");
			String url="jdbc:mysql://localhost:3306/mysql1";
			this.conn=DriverManager.getConnection(url, "root", "123456");
			System.out.println(this.conn.isClosed());	//是否连接成功，false 代表成功
			
			
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//增刪改
	public int update(String sql) {
		System.out.println("sql:"+sql);
		try {
			this.stmt=this.conn.createStatement();
			return this.stmt.executeUpdate(sql);		//返回 影响 了几行	
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return -1;		
	}
	//查询方法
	public ResultSet query(String sql) {
		System.out.println("sql:"+sql);
		try {
			this.stmt=this.conn.createStatement();
			return this.stmt.executeQuery(sql);
		}catch(SQLException e) {
			e.printStackTrace();
		}
		return null;
	}
}
 
2）测试——增删改、查询数据库中数据
 
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Main1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner get=new Scanner(System.in);
		DB db=new DB();
		while(true) {
			System.out.println("1.注册");
			System.out.println("2.修改密码");
			System.out.println("3.删除用户");
			System.out.println("4.显示用户");
			System.out.println("0.退出");
			String t=get.next();
			
			if("1".equals(t)) {//添加
				System.out.print("用户名：");
				String uname=get.next();
				System.out.print("密码：");
				String upass=get.next();
				String sql="INSERT INTO users VALUES (null,'"+uname+ "','" +upass+ "')";
				int res=db.update(sql);
				if(res==1) {
					System.out.println("注册成功");
				}else {
					System.out.println("注册失败");
				}
			}else if("2".equals(t)) {//修改
				System.out.print("用户名:");
				String uname=get.next();
				System.out.print("新密码:");
				String newPass=get.next();
				String sql="UPDATE users set upass='"  +newPass+  "' WHERE uname='"  +uname+  "' ";
				int res=db.update(sql);
				if(res>0) {
					System.out.println("修改成功");
				}else {
					System.out.println("修改失败");
				}
			}else if("3".equals(t)) {//删除
				System.out.println("输入id：");
				String uid=get.next();
				String sql="DELETE FROM users WHERE uid ="+uid+"";
				int res=db.update(sql);
				if(res>0) {
					System.out.println("删除成功");
				}else {
					System.out.println("删除失败");
				}
			}else if("0".equals(t)) {
				break;
			}else if("4".equals(t)) { //显示用户
				String sql="SELECT *FROM users";
				ResultSet rs=db.query(sql);
				try {
					while(rs.next()) {
						String deptno=rs.getString(1);
						String dname=rs.getString(2);
						String loc=rs.getString(3);
						System.out.println(deptno+"\t"+dname+"\t"+loc);
					}
				}catch(SQLException e) {
					e.printStackTrace();
				}
			}
			
		}
		get.close();
	}

}

        数据库连接池（Connection pooling）是程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由程序动态地对池中的连接进行申请，使用，释放。
 
        大家可以想一下，如果项目中没有数据库连接池会是一个什么样的结果？每访问一次数据库都会新建一个数据库连接，如果同事有成百上千的请求需要访问数据库那么项目会惨不忍睹。
 
        数据库连接池就是在项目启动是就已经创建了一定数量的数据库连接，有请求访问数据库时，不需要新建数据库连接，直接在连接池中拿就可以，用完了记得放到池子里面就行。这样的话，连接池中的数据库连接会不断的重复利用，大大提高了对数据库操作的性能。
 
 
 
 数据库连接池的运行机制有以下几点：
 
 1.程序启动时创建数据库连接池。
 
 2.使用连接时，从连接池中拿可用的数据库连接。
 
 3.使用完，将数据库连接放入数据库中。
 
 那么要想手动代码实现数据库连接池，需要哪些步骤了？下面会贴出源代码以及简单的注释。
 
 首先需要一个数据库连接池的配置文件jdbc.properties，内容如下：
 
#驱动名称  
jdbcDriver=com.mysql.jdbc.Driver  
#连接URL  
jdbcUrl=jdbc:mysql://localhost:3306/lcma  
#数据库账户名  
userName=root  
#数据库密码  
password=iflytek  
#初始化连接数  
initCount=10  
#步进数量  
stepSize=4  
#最大连接池个数  
poolMaxSize=150  
       既然是数据连接池，那么池子里面放的肯定是很多个数据库连接，一个数据库连接就是一个对象，建一个数据库连接类 PooledConnection.java代表数据库连接对象。类里面有个isBusy属性，用来表示该连接对象是否正在使用，若使用中用true表示，反之为false。代码如下：

 
既然是数据连接池，那么池子里面放的肯定是很多个数据库连接，一个数据库连接就是一个对象，建一个数据库连接类 PooledConnection.java代表数据库连接对象。类里面有个isBusy属性，用来表示该连接对象是否正在使用，若使用中用true表示，反之为false。代码如下：

 
 
 
package com.lcma.conn;

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

/**
 * <p>Title      : 存储连接池中对象属性</p>
 * <p>Description: [子应用名]_[模块名]</p>
 * <p>Copyright  : Copyright (c) 2016</p>
 * <p>Company    : 科大讯飞</p>
 * @author       : lcma
 * @version      : 1.0
 */
public class PooledConnection {
	
	/**
	 * 连接管道对象
	 */
	private Connection conn;
	
	/**
	 * 连接状态，true-繁忙，false-空闲
	 */
	private boolean isBusy = false;
	
	public PooledConnection(Connection conn, boolean isBusy){
		this.conn = conn;
		this.isBusy = isBusy;
	}
	
	public void close(){
		this.isBusy = false;
	}

	public Connection getConn() {
		return conn;
	}

	public void setConn(Connection conn) {
		this.conn = conn;
	}

	public boolean isBusy() {
		return isBusy;
	}

	public void setBusy(boolean isBusy) {
		this.isBusy = isBusy;
	}

	/**
	 * <p>Discription:创建查询方法,用于测试使用</p>
	 * @param sql
	 * @return
	 * @author       : lcma
	 * @update       : 2016年12月5日下午11:19:18
	 */
	public ResultSet queryBySql(String sql){
		ResultSet rs = null;
		Statement sm = null;
		try {
			sm = conn.createStatement();
			rs = sm.executeQuery(sql);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return rs;
	}
	
	
}
创建连接池接口类，IMyPool.java

 
package com.lcma.pools;  
  
import com.lcma.conn.PooledConnection;  
  
/** 
 * <p>Description: 连接池接口</p> 
 * <p>Copyright  : Copyright (c) 2017</p> 
 * @author       : lcma 
 * @version      : 1.0 
 */  
public interface IMyPool {  
      
    /** 
     * <p>Discription:创建连接</p> 
     * @param count 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:46 
     */  
    public void createConnection(int count);  
      
    /** 
     * <p>Discription:获取连接</p> 
     * @return 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:34 
     */  
    public PooledConnection getConnection();  
  
}
实现连接池接口类，MyPoolImpl.java 
 
 
 
 1.读取配置文件，创建连接池
 
 2.获取连接，判断是否有空闲的连接并且是有效的连接
 
package com.lcma.pools.impl;  
  
import java.io.IOException;  
import java.io.InputStream;  
import java.sql.Connection;  
import java.sql.Driver;  
import java.sql.DriverManager;  
import java.sql.SQLException;  
import java.util.Properties;  
import java.util.Vector;  
  
import com.lcma.conn.PooledConnection;  
import com.lcma.pools.IMyPool;  
  
/** 
 * <p>Title      : 连接池接口实现类</p> 
 * <p>Description: [子应用名]_[模块名]</p> 
 * <p>Copyright  : Copyright (c) 2016</p> 
 * <p>Company    : 科大讯飞</p> 
 * @author       : lcma 
 * @version      : 1.0 
 */  
public class MyPoolImpl implements IMyPool {  
    /** 
     * 驱动名称 
     */  
    private String jdbcDriver;  
    /** 
     * 连接地址 
     */  
    private String jdbcUrl;  
    /** 
     * 用户名 
     */  
    private String userName;  
    /** 
     * 密码 
     */  
    private String password;  
    /** 
     * 初始化连接数 
     */  
    private int initCount;  
    /** 
     * 步进连接数 
     */  
    private int stepSize;  
    /** 
     * 最大连接数 
     */  
    private int poolMaxSize;  
      
    /** 
     * 连接池容器 
     */  
    private static Vector<PooledConnection> pooledConnections = new Vector<PooledConnection>();  
      
    /** 
     * 构造函数，执行初始化方法 
     */  
    public MyPoolImpl() {  
        init();  
    }  
      
    /** 
     * <p>Discription:初始化连接池</p> 
     * @author       : lcma 
     * @update       : 2016年12月5日下午8:42:37 
     */  
    private void init(){  
        InputStream is = this.getClass().getClassLoader().getResourceAsStream("jdbc.properties");  
        Properties pro = new Properties();  
        try {  
            pro.load(is);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        jdbcDriver = pro.getProperty("jdbcDriver");  
        jdbcUrl = pro.getProperty("jdbcUrl");  
        userName = pro.getProperty("userName");  
        password = pro.getProperty("password");  
        initCount = Integer.parseInt(pro.getProperty("initCount"));  
        stepSize = Integer.parseInt(pro.getProperty("stepSize"));  
        poolMaxSize = Integer.parseInt(pro.getProperty("poolMaxSize"));  
          
        try {  
            Driver driver = (Driver)Class.forName(jdbcDriver).newInstance();  
            //将driver注册  
            DriverManager.registerDriver(driver);;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        //创建连接  
        createConnection(initCount);  
    }  
  
    /** 
     * <p>Discription:创建连接</p> 
     * @param count 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:46 
     */  
    @Override  
    public void createConnection(int count) {  
        if(poolMaxSize<=0 || pooledConnections.size()+count > poolMaxSize){  
            System.out.println("创建连接失败，超过最大连接数");  
            throw new RuntimeException("创建连接失败，超过最大连接数");  
        }  
        try {  
            //循环创建连接  
            for(int i = 0; i < count; i++){  
                 //创建连接  
                Connection connection = DriverManager.getConnection(jdbcUrl, userName, password);  
                //实例化连接池中的连接  
                PooledConnection pooledConnection = new PooledConnection(connection, false);  
                //存入连接池容器  
                pooledConnections.add(pooledConnection);  
            }  
         } catch (SQLException e) {  
            e.printStackTrace();  
        }  
          
    }  
  
    /** 
     * <p>Discription:获取连接</p> 
     * @return 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:34 
     */  
    @Override  
    public PooledConnection getConnection() {  
        if(pooledConnections.size()<=0){  
            System.out.println("获取连接失败，连接池为空");  
            throw new RuntimeException("获取连接失败，连接池为空");  
        }  
        PooledConnection connection = getRealConnection();  
        //判断是否为空  
        while(connection == null){  
            //创建connection，步进数  
            createConnection(stepSize);  
            //重新获取连接，有可能获取的还为空,采用while循环判断  
            getRealConnection();  
            //防止其他线程过来拿连接  
            try {  
                Thread.sleep(300);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        return connection;  
    }  
      
    //判断我们是否拿到有效的连接对象  
    private synchronized PooledConnection getRealConnection(){  
        //先判断连接池是不是有我们需要的空闲连接对象  
        for(PooledConnection connection : pooledConnections){  
            //未处于繁忙状态  
            if(!connection.isBusy()){  
                Connection conn = connection.getConn();  
                try {  
                    //判断这个连接是不是有效，isValid就是创建了一个statement，执行sql语句，看是否成功  
                    if(!conn.isValid(2000)){  
                        Connection validConn = DriverManager.getConnection(jdbcUrl, userName, password);  
                        connection.setConn(validConn);  
                    }  
                } catch (SQLException e) {  
                    e.printStackTrace();  
                }  
                //设置为繁忙  
                connection.setBusy(true);  
                return connection;  
            }  
        }  
        return null;  
    }  
  
    public String getJdbcDriver() {  
        return jdbcDriver;  
    }  
  
    public void setJdbcDriver(String jdbcDriver) {  
        this.jdbcDriver = jdbcDriver;  
    }  
  
    public String getJdbcUrl() {  
        return jdbcUrl;  
    }  
  
    public void setJdbcUrl(String jdbcUrl) {  
        this.jdbcUrl = jdbcUrl;  
    }  
  
    public String getUserName() {  
        return userName;  
    }  
  
    public void setUserName(String userName) {  
        this.userName = userName;  
    }  
  
    public String getPassword() {  
        return password;  
    }  
  
    public void setPassword(String password) {  
        this.password = password;  
    }  
  
    public int getInitCount() {  
        return initCount;  
    }  
  
    public void setInitCount(int initCount) {  
        this.initCount = initCount;  
    }  
  
    public int getStepSize() {  
        return stepSize;  
    }  
  
    public void setStepSize(int stepSize) {  
        this.stepSize = stepSize;  
    }  
  
    public int getPoolMaxSize() {  
        return poolMaxSize;  
    }  
  
    public void setPoolMaxSize(int poolMaxSize) {  
        this.poolMaxSize = poolMaxSize;  
    }  
  
  
} 
创建PoolManager类，利用内部类单例模式解决多线程问题，
多个线程在加载内部类的时候线程是互斥的
，解决了线程安全问题。

 
package com.lcma.manager;  
  
import com.lcma.pools.impl.MyPoolImpl;  
  
/** 
 * <p>Title      : 利用内部类单例模式解决多线程问题</p> 
 * <p>Description: [子应用名]_[模块名]</p> 
 * <p>Copyright  : Copyright (c) 2016</p> 
 * <p>Company    : 科大讯飞</p> 
 * @author       : lcma 
 * @version      : 1.0 
 */  
public class PoolManager {  
      
    private static class creatPool{  
        private static MyPoolImpl poolImpl = new MyPoolImpl();  
    }  
      
    //多个线程在加载内部类的时候线程是互斥的，所以用单例模式的内部类形式避免线程混乱  
    public static MyPoolImpl getInstace(){  
        return creatPool.poolImpl;  
    }  
  
} 
测试类MyPoolMain,测试2000个线程同时请求数据库，程序应对自如，这就是数据库连接池的强大之处。

 
package com.lcma.main;  
  
import java.sql.ResultSet;  
import java.sql.SQLException;  
  
import com.lcma.conn.PooledConnection;  
import com.lcma.manager.PoolManager;  
import com.lcma.pools.impl.MyPoolImpl;  
  
/**  
 * <p>Description: 测试类</p>  
 * <p>Copyright  : Copyright (c) 2017</p>  
 * @author       : lcma  
 * @version      : 1.0  
 */  
public class MyPoolMain {  
      
    /**  
     * 获取连接池容器实现类  
     */  
    private static MyPoolImpl poolImpl = PoolManager.getInstace();  
      
    /**  
     * 单个连接查询测试  
     */  
    public synchronized static void selectData(){  
        PooledConnection connection = poolImpl.getConnection();  
        ResultSet rs = connection.queryBySql("select * from class");  
        try {  
            while(rs.next()){  
                System.out.print(rs.getString("ID") + "\t\t");  
                System.out.print(rs.getString("NAME") + "\t\t");  
                System.out.print(rs.getString("TEACHER") + "\t\t");  
                System.out.println();  
            }  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }finally {  
            try {rs.close();} catch (SQLException e) {e.printStackTrace();}  
            connection.close();  
        }  
    }  
      
    /**  
     * <p>Discription:测试2000个线程</p>  
     * @param args  
     * @author       : lcma  
     * @update       : 2016年12月5日下午11:44:18  
     */  
    public static void main(String[] args){  
        for (int i = 0; i < 2000; i++) {  
            new Thread(new Runnable() {  
                public void run() {  
                    selectData();  
                    System.out.println();  
                }  
            }).start();  
        }  
          
    }  
  
} 

 
注：上面代码只对功能做出实现，对代码规范性并没有做太高要求。