在一个应用里面，可能涉及到连接多个不同数据库进行操作，而每次连接写不同的实现会很麻烦。前面已经会了用JDBC连接数据库，那么利用反射和工厂模式，可以实现连接不同的数据库，这样处理起来将会很方便。同时建造数据库连接池，处理多个业务数据处理。
那么具体怎么实现呢，下面一起来看一下：
整体结构如下：
第一步，先处理连接不同数据库
1、首先，将数据库配置信息创建一个公用类：JdbcUrl.java
主数据库可以用默认的构造方法，如果是连接其他库，则通过传递参数的方式来处理。
数据库参数有如下几个：
1 /** 2 * 数据库连接配置信息类 3 * @author Damon 4 */ 5 public class JdbcUrl 6 { 7 8 /** 定义数据库参数 */ 9 10 // 数据库类型 11 private String DBType; 12 // 数据库服务器IP 13 private String IP; 14 // 数据库服务器端口 15 private String Port; 16 // 数据库名称 17 private String DBName; 18 // 用户名 19 private String UserName; 20 // 密码 21 private String PassWord; 22 23 24 /** 25 * 默认构造方法，连接默认数据库 26 */ 27 public JdbcUrl() 28 { 29 // TODO Auto-generated constructor stub 30 DBType = SysCon.DATABASE_TYPE_MYSQL; 31 IP = "127.0.0.1"; 32 DBName = "mysql"; 33 Port = "3306"; 34 UserName = "damon"; 35 PassWord = "damon"; 36 } 37 38 /** 39 * 连接指定数据库 40 * @param urlType 传入连接类型标识 41 */ 42 public JdbcUrl(String urlType) 43 { 44 if ("mysql".equals(urlType)) 45 { 46 DBType = SysCon.DATABASE_TYPE_MYSQL; 47 IP = "127.0.0.1"; 48 DBName = "mysql"; 49 Port = "3306"; 50 UserName = "damon"; 51 PassWord = "damon"; 52 } 53 } 54 55 /** 56 * 获取连接句柄 57 * @return String 58 */ 59 public String getJdbcUrl() 60 { 61 String sUrl = ""; 62 63 if (DBType.trim().toUpperCase().equals("MYSQL")) 64 { 65 sUrl = "jdbc:mysql://" + IP + ":" + Port + "/" + DBName; 66 } 67 else if (DBType.trim().toUpperCase().equals("DB2")) 68 { 69 sUrl = "jdbc:db2://" + IP + ":" + Port + "/" + DBName; 70 } 71 72 else if (DBType.trim().toUpperCase().equals("ORACLE")) 73 { 74 sUrl = "jdbc:oracle:thin:@" + IP + ":" + Port + ":" + DBName; 75 } 76 77 else if (DBType.trim().toUpperCase().equals("SQLSERVER")) 78 { 79 sUrl = "jdbc:microsoft:sqlserver://" + IP + ":" + Port + ";databaseName=" + DBName + ";selectMethod=cursor"; 80 } 81 else if (DBType.trim().toUpperCase().equals("WEBLOGICPOOL")) 82 { 83 sUrl = "jdbc:weblogic:pool:" + DBName; 84 } 85 else 86 { 87 System.out.println("暂无对应数据库驱动"); 88 } 89 return sUrl; 90 } 91 92 // getters and setters 93 94 public String getDBType() 95 { 96 return DBType; 97 } 98 99 public void setDBType(String dBType) 100 { 101 DBType = dBType; 102 } 103 104 public String getIP() 105 { 106 return IP; 107 } 108 109 public void setIP(String iP) 110 { 111 IP = iP; 112 } 113 114 public String getPort() 115 { 116 return Port; 117 } 118 119 public void setPort(String port) 120 { 121 Port = port; 122 } 123 124 public String getDBName() 125 { 126 return DBName; 127 } 128 129 public void setDBName(String dBName) 130 { 131 DBName = dBName; 132 } 133 134 public String getUserName() 135 { 136 return UserName; 137 } 138 139 public void setUserName(String userName) 140 { 141 UserName = userName; 142 } 143 144 public String getPassWord() 145 { 146 return PassWord; 147 } 148 149 public void setPassWord(String passWord) 150 { 151 PassWord = passWord; 152 } 153 154 }
2、重写一个Connection类，实现Connection接口的方法，同时连接数据库。
参数有已实现的JdbrUrl类，主要新增方法为：createConnection()
根据DBType来对不同数据库进行处理：加载对应的数据库，然后获取数据库连接。
1 ** 2 * 数据库连接类，连接数据库 3 * @author Damon 4 */ 5 public class DBConn implements Connection 6 { 7 8 // 获取JdbcUrl信息 9 private JdbcUrl JUrl; 10 11 // 数据库连接 12 private Connection con = null; 13 14 // 连接是否已使用 15 private boolean bNotInUse; 16 17 private CharArrayWriter m_buf = new CharArrayWriter(); 18 19 private PrintWriter m_pw = new PrintWriter(m_buf, true); 20 21 // 默认连接 22 public DBConn() 23 { 24 // TODO Auto-generated constructor stub 25 this.JUrl = new JdbcUrl(); 26 } 27 28 // 指定数据库连接 29 public DBConn(String urlType) 30 { 31 this.JUrl = new JdbcUrl(urlType); 32 } 33 34 // 创建连接 35 public boolean createConnection() 36 { 37 38 // 根据数据库类型加载驱动及连接 39 try 40 { 41 // 连接MySQL数据库 42 if (SysCon.DATABASE_TYPE_MYSQL.equals(JUrl.getDBType())) 43 { 44 // 加载数据库驱动 45 Class.forName("com.mysql.jdbc.Driver"); 46 47 // 尝试连接数据库 48 con = DriverManager.getConnection(JUrl.getJdbcUrl(), JUrl.getUserName(), JUrl.getPassWord()); 49 } 50 // 其他数据库类型判断及处理 51 // SQLSERVER 52 else if (SysCon.DATABASE_TYPE_SQLSERVER.equals(JUrl.getDBType())) 53 { 54 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver"); 55 con = DriverManager.getConnection(JUrl.getJdbcUrl(), JUrl.getUserName(), JUrl.getPassWord()); 56 } 57 // DB2 58 else if (SysCon.DATABASE_TYPE_DB2.equals(JUrl.getDBType())) 59 { 60 Class.forName("com.ibm.db2.jcc.DB2Driver"); 61 con = DriverManager.getConnection(JUrl.getJdbcUrl(), JUrl.getUserName(), JUrl.getPassWord()); 62 } 63 // ORACLE 64 else if (SysCon.DATABASE_TYPE_ORACLE.equals(JUrl.getDBType())) 65 { 66 Class.forName("oracle.jdbc.driver.OracleDriver"); 67 // 一个是缓存取到的记录数，一个是设置默认的批量提交数 68 Properties props = new Properties(); 69 props.setProperty("user", JUrl.getUserName()); 70 props.setProperty("password", JUrl.getPassWord()); 71 props.setProperty("defaultRowPrefetch", "50"); 72 props.setProperty("defaultExecuteBatch", "50"); 73 con = DriverManager.getConnection(JUrl.getJdbcUrl(), props); 74 } 75 else 76 { 77 System.out.println("未匹配到数据库类型！"); 78 return false; 79 } 80 81 } 82 catch (ClassNotFoundException e) 83 { 84 // TODO Auto-generated catch block 85 System.out.println("加载驱动失败！"); 86 e.printStackTrace(); 87 return false; 88 } 89 catch (SQLException e) 90 { 91 // TODO Auto-generated catch block 92 System.out.println("创建连接失败..." + e.getMessage()); 93 e.printStackTrace(); 94 return false; 95 } 96 return true; 97 } 98 99 protected void setInUse() 100 { 101 /** 102 * Record stack information when each connection is get We reassian 103 * System.err, so Thread.currentThread().dumpStack() can dump stack info 104 * into our class FilterPrintStream. 105 */ 106 new Throwable().printStackTrace(m_pw); 107 108 bNotInUse = false; 109 110 /** 111 * record lastest access time 112 */ 113 } 114 115 /* 下面都是 实现Connection的方法，返回conn的实现 */ 116 public <T> T unwrap(Class<T> iface) throws SQLException 117 { 118 // TODO Auto-generated method stub 119 return con.unwrap(null); 120 } 121 122 public boolean isWrapperFor(Class<?> iface) throws SQLException 123 { 124 // TODO Auto-generated method stub 125 return false; 126 } 127 128 public Statement createStatement() throws SQLException 129 { 130 // TODO Auto-generated method stub 131 return con.createStatement(); 132 } 133 134 public PreparedStatement prepareStatement(String sql) throws SQLException 135 { 136 // TODO Auto-generated method stub 137 return con.prepareStatement(sql); 138 } 139 140 public CallableStatement prepareCall(String sql) throws SQLException 141 { 142 // TODO Auto-generated method stub 143 return con.prepareCall(sql); 144 } 145 146 public String nativeSQL(String sql) throws SQLException 147 { 148 // TODO Auto-generated method stub 149 return con.nativeSQL(sql); 150 } 151 152 public void setAutoCommit(boolean autoCommit) throws SQLException 153 { 154 // TODO Auto-generated method stub 155 con.setAutoCommit(autoCommit); 156 } 157 158 public boolean getAutoCommit() throws SQLException 159 { 160 // TODO Auto-generated method stub 161 return con.getAutoCommit(); 162 } 163 164 public void commit() throws SQLException 165 { 166 // TODO Auto-generated method stub 167 con.commit(); 168 } 169 170 public void rollback() throws SQLException 171 { 172 // TODO Auto-generated method stub 173 con.rollback(); 174 } 175 176 public void close() throws SQLException 177 { 178 // TODO Auto-generated method stub 179 con.close(); 180 } 181 182 public boolean isClosed() throws SQLException 183 { 184 // TODO Auto-generated method stub 185 186 return con.isClosed(); 187 } 188 189 public DatabaseMetaData getMetaData() throws SQLException 190 { 191 // TODO Auto-generated method stub 192 return con.getMetaData(); 193 } 194 195 public void setReadOnly(boolean readOnly) throws SQLException 196 { 197 // TODO Auto-generated method stub 198 con.setReadOnly(readOnly); 199 } 200 201 public boolean isReadOnly() throws SQLException 202 { 203 // TODO Auto-generated method stub 204 return con.isReadOnly(); 205 } 206 207 public void setCatalog(String catalog) throws SQLException 208 { 209 // TODO Auto-generated method stub 210 con.setCatalog(catalog); 211 } 212 213 public String getCatalog() throws SQLException 214 { 215 // TODO Auto-generated method stub 216 return con.getCatalog(); 217 } 218 219 public void setTransactionIsolation(int level) throws SQLException 220 { 221 // TODO Auto-generated method stub 222 con.setTransactionIsolation(level); 223 } 224 225 public int getTransactionIsolation() throws SQLException 226 { 227 // TODO Auto-generated method stub 228 return con.getTransactionIsolation(); 229 } 230 231 public SQLWarning getWarnings() throws SQLException 232 { 233 // TODO Auto-generated method stub 234 return con.getWarnings(); 235 } 236 237 public void clearWarnings() throws SQLException 238 { 239 // TODO Auto-generated method stub 240 con.clearWarnings(); 241 } 242 243 public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException 244 { 245 // TODO Auto-generated method stub 246 return con.createStatement(resultSetType, resultSetConcurrency); 247 } 248 249 public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) 250 throws SQLException 251 { 252 // TODO Auto-generated method stub 253 return con.prepareStatement(sql, resultSetType, resultSetConcurrency); 254 } 255 256 public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException 257 { 258 // TODO Auto-generated method stub 259 return con.prepareCall(sql, resultSetType, resultSetConcurrency); 260 } 261 262 public Map<String, Class<?>> getTypeMap() throws SQLException 263 { 264 // TODO Auto-generated method stub 265 return con.getTypeMap(); 266 } 267 268 public void setTypeMap(Map<String, Class<?>> map) throws SQLException 269 { 270 // TODO Auto-generated method stub 271 con.setTypeMap(map); 272 } 273 274 public void setHoldability(int holdability) throws SQLException 275 { 276 // TODO Auto-generated method stub 277 con.setHoldability(holdability); 278 } 279 280 public int getHoldability() throws SQLException 281 { 282 // TODO Auto-generated method stub 283 return con.getHoldability(); 284 } 285 286 public Savepoint setSavepoint() throws SQLException 287 { 288 // TODO Auto-generated method stub 289 return con.setSavepoint(); 290 } 291 292 public Savepoint setSavepoint(String name) throws SQLException 293 { 294 // TODO Auto-generated method stub 295 return con.setSavepoint(name); 296 } 297 298 public void rollback(Savepoint savepoint) throws SQLException 299 { 300 // TODO Auto-generated method stub 301 con.rollback(savepoint); 302 } 303 304 public void releaseSavepoint(Savepoint savepoint) throws SQLException 305 { 306 // TODO Auto-generated method stub 307 con.releaseSavepoint(savepoint); 308 } 309 310 public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) 311 throws SQLException 312 { 313 // TODO Auto-generated method stub 314 return con.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability); 315 } 316 317 public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, 318 int resultSetHoldability) throws SQLException 319 { 320 // TODO Auto-generated method stub 321 return con.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability); 322 } 323 324 public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, 325 int resultSetHoldability) throws SQLException 326 { 327 // TODO Auto-generated method stub 328 return null; 329 } 330 331 public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException 332 { 333 // TODO Auto-generated method stub 334 return con.prepareStatement(sql, autoGeneratedKeys); 335 } 336 337 public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException 338 { 339 // TODO Auto-generated method stub 340 return con.prepareStatement(sql, columnIndexes); 341 } 342 343 public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException 344 { 345 // TODO Auto-generated method stub 346 return con.prepareStatement(sql, columnNames); 347 } 348 349 public Clob createClob() throws SQLException 350 { 351 // TODO Auto-generated method stub 352 return con.createClob(); 353 } 354 355 public Blob createBlob() throws SQLException 356 { 357 // TODO Auto-generated method stub 358 return con.createBlob(); 359 } 360 361 public NClob createNClob() throws SQLException 362 { 363 // TODO Auto-generated method stub 364 return con.createNClob(); 365 } 366 367 public SQLXML createSQLXML() throws SQLException 368 { 369 // TODO Auto-generated method stub 370 return con.createSQLXML(); 371 } 372 373 public boolean isValid(int timeout) throws SQLException 374 { 375 // TODO Auto-generated method stub 376 return con.isValid(timeout); 377 } 378 379 public void setClientInfo(String name, String value) throws SQLClientInfoException 380 { 381 // TODO Auto-generated method stub 382 con.setClientInfo(name, value); 383 } 384 385 public void setClientInfo(Properties properties) throws SQLClientInfoException 386 { 387 // TODO Auto-generated method stub 388 con.setClientInfo(properties); 389 } 390 391 public String getClientInfo(String name) throws SQLException 392 { 393 // TODO Auto-generated method stub 394 return con.getClientInfo(name); 395 } 396 397 public Properties getClientInfo() throws SQLException 398 { 399 // TODO Auto-generated method stub 400 return con.getClientInfo(); 401 } 402 403 public Array createArrayOf(String typeName, Object[] elements) throws SQLException 404 { 405 // TODO Auto-generated method stub 406 return con.createArrayOf(typeName, elements); 407 } 408 409 public Struct createStruct(String typeName, Object[] attributes) throws SQLException 410 { 411 // TODO Auto-generated method stub 412 return con.createStruct(typeName, attributes); 413 } 414 415 }
3、公共的数据库连接池
数据库配置和数据库连接已经搞定，那么可以建一个数据库连接池来进行数据库的连接及处理。
主要有2个方法，连接默认数据库和连接指定的数据库。
1 /** 2 * 获取默认数据库连接 3 * @param uri 4 * @return 5 */ 6 public static DBConn getConnection() 7 { 8 DBConn dbConn = new DBConn(); 9 if (!dbConn.createConnection()) 10 { 11 // 如果创建连接失败 12 DBSemaphore.unLock(); 13 return null; 14 } 15 16 // 连接成功，设置该连接属性 17 try 18 { 19 // 特殊处理连接的AutoCommit是否已经被设置 20 dbConn.setAutoCommit(true); 21 dbConn.setInUse(); 22 DBSemaphore.unLock(); 23 return dbConn; 24 } 25 catch (Exception ex) 26 { 27 ex.printStackTrace(); 28 DBSemaphore.unLock(); 29 return null; 30 } 31 32 } 33 34 /** 35 * 通过URI地址获取指定数据库连接 36 * @param uri 37 * @return 38 */ 39 public static DBConn getConnection(String uri) 40 { 41 DBConn dbConn = new DBConn(uri); 42 if (!dbConn.createConnection()) 43 { 44 // 如果创建连接失败 45 // DBSemaphore.UnLock(); 46 return null; 47 } 48 try 49 { 50 // 特殊处理连接的AutoCommit是否已经被设置 51 dbConn.setAutoCommit(true); 52 // dbConn.setInUse(); 53 // DBSemaphore.UnLock(); 54 return dbConn; 55 } 56 catch (Exception ex) 57 { 58 ex.printStackTrace(); 59 // DBSemaphore.UnLock(); 60 return null; 61 } 62 63 }
可以写一个测试方式，这也数据库连接就完成了，通过传入不同的参数就可以获取到不同数据库的连接了。
1 public static void main(String[] args) 2 { 3 // 测试连接池 4 5 // 1、连接mysql 数据库 6 Connection conn = DBConnPool.getConnection(); 7 8 if (conn == null) 9 { 10 System.out.println("获取连接失败！"); 11 } 12 else 13 { 14 System.out.println("获取连接成功"); 15 } 16 17 }
第二步，构建数据库连接池
前面已经实现连接不同数据库，那么怎么处理为连接池呢？
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。下面我们就来实现数据库连接池的功能：
数据库连接池的实现思想主要有如下几个方面：
1、可定义最大和最小的连接数：如果请求小于最小连接数，则直接分配连接，达到最大连接数则新请求等待；
2、用户在连接数据库时，不用新建连接，而是直接从连接池中获取连接，使用完毕后也不用关闭，而是释放给连接池，供下一个用户使用；
下面来进行实现：
其实就是实现了一个数据连接数的判断，最大连接数进行限制，实际的数据库连接池需结合对应的数据库连接池组件（比如 WebSphere等中间件），在判断是否有连接在使用的时候，会涉及到并发，这里需要用到volatile关键字。
其中，增加了DBsemaphor类，用以处理连接的使用和释放。
在原有DBConn基础上，加上是否已使用方法，在获取连接成功时调用，具体代码如下：
1 // 连接成功，设置该连接属性 2 try 3 { 4 // 特殊处理连接的AutoCommit是否已经被设置 5 dbConn.setAutoCommit(true); 6 dbConn.setInUse(); 7 DBSemaphore.unLock(); 8 return dbConn; 9 } 10 catch (Exception ex) 11 { 12 ex.printStackTrace(); 13 DBSemaphore.unLock(); 14 return null; 15 }
新增DBSemaphore类属性及方法如下：
1 /** 2 * 数据库同步对象 3 * @author Damon 4 */ 5 public class DBSemaphore 6 { 7 private static volatile boolean m_bInUse = false; 8 9 public DBSemaphore() 10 {} 11 12 /** 13 * 设置"使用标志"。 传入true表示请求“使用标志”，传入false表示释放“使用标志”。 14 * @param bNewValue boolean 15 * @return boolean 16 */ 17 protected static synchronized boolean setInUseFlag(boolean bNewValue) 18 { 19 if (bNewValue == true) 20 { 21 // 请求“使用标志” 22 if (m_bInUse == true) 23 { 24 // “使用标志”已经被占用 25 return false; 26 } 27 else 28 { 29 m_bInUse = true; 30 return true; 31 } 32 } 33 else 34 { 35 // 释放“使用标志” 36 m_bInUse = false; 37 return true; 38 } 39 } 40 41 protected static void lock() throws Exception 42 { 43 lock(0); 44 } 45 46 protected static void lock(int nSeconds) throws Exception 47 { 48 if (nSeconds <= 0) 49 { 50 while (!setInUseFlag(true)) 51 { 52 Thread.sleep(100); 53 } 54 } 55 else 56 { 57 while (!setInUseFlag(true) && nSeconds-- > 0) 58 { 59 Thread.sleep(100); 60 } 61 62 if (nSeconds == 0) 63 { 64 throw new Exception("Lock time out"); 65 } 66 } 67 } 68 69 protected static void unLock() 70 { 71 setInUseFlag(false); 72 } 73 }
到这里，整个配置处理结束了，更多的就需要在实际项目中发挥了~