在一个应用里面,可能涉及到连接多个不同数据库进行操作,而每次连接写不同的实现会很麻烦。前面已经会了用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. public JdbcUrl()
  27. {
  28. // TODO Auto-generated constructor stub
  29. DBType = SysCon.DATABASE_TYPE_MYSQL;
  30. IP = "127.0.0.1";
  31. DBName = "mysql";
  32. Port = "3306";
  33. UserName = "damon";
  34. PassWord = "damon";
  35. }
  36.  
  37. /**
  38. * 连接指定数据库
  39. * @param urlType 传入连接类型标识
  40. */
  41. public JdbcUrl(String urlType)
  42. {
  43. if ("mysql".equals(urlType))
  44. {
  45. DBType = SysCon.DATABASE_TYPE_MYSQL;
  46. IP = "127.0.0.1";
  47. DBName = "mysql";
  48. Port = "3306";
  49. UserName = "damon";
  50. PassWord = "damon";
  51. }
  52. }
  53.  
  54. /**
  55. * 获取连接句柄
  56. * @return String
  57. */
  58. public String getJdbcUrl()
  59. {
  60. String sUrl = "";
  61.  
  62. if (DBType.trim().toUpperCase().equals("MYSQL"))
  63. {
  64. sUrl = "jdbc:mysql://" + IP + ":" + Port + "/" + DBName;
  65. }
  66. else if (DBType.trim().toUpperCase().equals("DB2"))
  67. {
  68. sUrl = "jdbc:db2://" + IP + ":" + Port + "/" + DBName;
  69. }
  70.  
  71. else if (DBType.trim().toUpperCase().equals("ORACLE"))
  72. {
  73. sUrl = "jdbc:oracle:thin:@" + IP + ":" + Port + ":" + DBName;
  74. }
  75.  
  76. else if (DBType.trim().toUpperCase().equals("SQLSERVER"))
  77. {
  78. sUrl = "jdbc:microsoft:sqlserver://" + IP + ":" + Port + ";databaseName=" + DBName + ";selectMethod=cursor";
  79. }
  80. else if (DBType.trim().toUpperCase().equals("WEBLOGICPOOL"))
  81. {
  82. sUrl = "jdbc:weblogic:pool:" + DBName;
  83. }
  84. else
  85. {
  86. System.out.println("暂无对应数据库驱动");
  87. }
  88. return sUrl;
  89. }
  90.  
  91. // getters and setters
  92.  
  93. public String getDBType()
  94. {
  95. return DBType;
  96. }
  97.  
  98. public void setDBType(String dBType)
  99. {
  100. DBType = dBType;
  101. }
  102.  
  103. public String getIP()
  104. {
  105. return IP;
  106. }
  107.  
  108. public void setIP(String iP)
  109. {
  110. IP = iP;
  111. }
  112.  
  113. public String getPort()
  114. {
  115. return Port;
  116. }
  117.  
  118. public void setPort(String port)
  119. {
  120. Port = port;
  121. }
  122.  
  123. public String getDBName()
  124. {
  125. return DBName;
  126. }
  127.  
  128. public void setDBName(String dBName)
  129. {
  130. DBName = dBName;
  131. }
  132.  
  133. public String getUserName()
  134. {
  135. return UserName;
  136. }
  137.  
  138. public void setUserName(String userName)
  139. {
  140. UserName = userName;
  141. }
  142.  
  143. public String getPassWord()
  144. {
  145. return PassWord;
  146. }
  147.  
  148. public void setPassWord(String passWord)
  149. {
  150. PassWord = passWord;
  151. }
  152.  
  153. }

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. }

到这里,整个配置处理结束了,更多的就需要在实际项目中发挥了~

 

Java创建连接池连接不同数据库的更多相关文章

  1. JNDI连接池连接Oracle数据库

    今天做了一个评论的小功能,要求用JNDI连接池连接Oracle数据库,以前只是测试了是否连接的上,现在没想到一个JNDI连接池连接Oracle数据库,纠结了好久,原来都是Oracle数据库的问题,这是 ...

  2. python使用dbutils的PooledDB连接池,操作数据库

    1.使用dbutils的PooledDB连接池,操作数据库. 这样就不需要每次执行sql后都关闭数据库连接,频繁的创建连接,消耗时间 2.如果是使用一个连接一直不关闭,多线程下,插入超长字符串到数据库 ...

  3. spring boot配置druid连接池连接mysql

    Spring Boot 集成教程 Spring Boot 介绍 Spring Boot 开发环境搭建(Eclipse) Spring Boot Hello World (restful接口)例子 sp ...

  4. node 连接MySQL及其分装, 连接池连接

    const mysql = require('mysql') const config = require('./../../config/config.default') var connectio ...

  5. python通过连接池连接redis,操作redis队列

    在每次使用redis都进行连接的话会拉低redis的效率,都知道redis是基于内存的数据库,效率贼高,所以每次进行连接比真正使用消耗的资源和时间还多.所以为了节省资源,减少多次连接损耗,连接池的作用 ...

  6. Java使用数据库连接池连接Oracle数据库

    第一步:导入tomcat\lib 下的一个tomcat-dbcp.jar包第二步:在web\META-INF下新建一个context.xml文件,文件内容如下: <?xml version=&q ...

  7. Spring框架中 配置c3p0连接池 完成对数据库的访问

    开发准备: 1.导入jar包: ioc基本jar jdbcTemplate基本jar c3p0基本jar 别忘了mysql数据库驱动jar 原始程序代码:不使用配置文件方式(IOC)生成访问数据库对象 ...

  8. 关于c3p0连接池连接mysql数据库需要注意的几点

    什么是数据库连接池: 用池来管理Connection,这可以重复使用Connection.有了池,所以我们就不用自己来创建Connection,而是通过池来获取Connection对象. 当使用完Co ...

  9. python - DBUtils 连接池减少oracle数据库的连接数

    问题: 接到需求,告知项目的oracle连接次数过多,对系统造成太过大的负担,要求减少oracle数据库的连接次数 分析: 仔细分析代码以后,发现产生问题的原因,在于之前要求提升oracle监控的监控 ...

随机推荐

  1. java基础(三章)

    java基础(三章) 一.基本if结构 1.流程图 l  输入输出 l  判断和分支 l  流程线 1.1              简单的if条件判断 if(表达式){            //表 ...

  2. 允许mysql用户从远程登录

    1.修改/etc/mysql/my.cnf,将下面的行注释掉bind=127.0.0.1注释#bind=127.0.0.1 2.修改用户权限,允许从任何主机登录mysql>use mysql;m ...

  3. PHP中常量和变量的区别

    1.常量只能赋一次值: 以下是申请常量的两种方法: const THE_VALUE="one"; define("THE_VALUE","one&qu ...

  4. windows端口占用处理工具

    一.描述 笔者在最近使用tomcat时,老是会遇到这种端口占用的问题,便写了这个小的exe,用于解决windows下的端口占用问题. 好吧,其实是我实在记不住CMD下的那几行命令.这玩意的实现比较简单 ...

  5. 增强学习 | AlphaGo背后的秘密

    "敢于尝试,才有突破" 2017年5月27日,当今世界排名第一的中国棋手柯洁与AlphaGo 2.0的三局对战落败.该事件标志着最新的人工智能技术在围棋竞技领域超越了人类智能,借此 ...

  6. 类型转换之 PropertyEditorSupport类

    这个类可以用于自定义的类型转换, 子类继承这个类之后可以重写子类的方法 ,其中比较重要的是setAsText和setValue方法,setAsText 子自己的方式处理转换,setValue将转换的结 ...

  7. 针对Oracle数据库表中的数据的常见操作

    1.查询表中所有数据 select * from 表名; 例:select * from stu; 2.查询的同时修改表中数据 select * from 表名  for update; 例:sele ...

  8. php打包文件为ZIP包后下载到本地

    这是一个工作中需要打包下载当前产品的所有图片到本地,文件格式为ZIP压缩包,打包下载文件跟图片一样,本程序细节为实际情况,使用需按照自己实际情况书写:<?php/**************** ...

  9. html的基本标记符号

    文本标记:<h1><h2><h3><h4><h5><h6>: 段落标记:<p>: 空格:&nbsp: 换行: ...

  10. Java虚拟机-----------Java内存区域与内存溢出异常

    Java内存区域划分 Java虚拟机运行时的数据区大致可划分为五部分:方法区,堆(两部分组成Java堆内存),虚拟机栈,本地方法栈(Java栈内存),程序计数器. 1.程序计数器 程序计数器占较小的内 ...