トップ 差分 一覧 ソース 置換 検索 ヘルプ PDF RSS ログイン

JDBC操作クラス

DBAccessor

JDBC経由でDBを操作するクラス

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;

/**
* DBにアクセスするためのクラス
*/
public class DBAccessor implements Cloneable {
  /** エラーをどこにも出力しない */
  final public static int TO_NO = 0;
  /** エラーをコンソールに出力する */
  final public static int TO_CONSOLE = 1;
  /** エラーをLogを使って出力する */
  final public static int TO_LOG = 2;
  /** エラーをDialogに出力する */
  final public static int TO_DIALOG = 3;
  
  /** データを読み込むモード */
  public static enum MODE {
    ALL, //全データを読み込む
    ONE  //1レコードだけ読み込む
  }
  
  /** エラー時にログの出力先 */
  protected int errorLog = TO_CONSOLE;
  
  /**  データベースコネクション */
  protected Connection con = null;
  /**  接続文字列(URL) */
  protected String connectionString = null;
  /**  ドライバ名 */
  protected String driverName = null;
  /**  パスワード */
  protected String pass = null;
  
  private static DBAccessor self = null;
  /**  ユーザ名 */
  protected String user = null;
  
  
  /**
  * コンストラクタ。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  */
  public DBAccessor(String driverName, String connectionString, String user, String pass) {
    this(driverName, connectionString, user, pass, TO_CONSOLE);
  }
  
  /**
  * コンストラクタ。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  */
  public DBAccessor(String driverName, String connectionString, String user, String pass, int errorLog) {
    this.errorLog = errorLog;
    this.driverName = driverName;
    this.connectionString = connectionString;
    this.user = user;
    this.pass = pass;
    
    try {
      Class.forName(driverName);
    } catch (Exception e) {
      this.outputException(e);
    }
  }
  
  
  @Override
  public Object clone(){
    return new DBAccessor(
      this.driverName,
      this.connectionString,
      this.user,
      this.pass,
      this.errorLog);
  }

  
  
  /**  接続を閉じる */
  public void close() {
    if (!isClosed()) {
      try {
        con.close();
      } catch (Exception e) {
        this.outputException(e);
      }
      con = null;
    }
  }
  
  /**
  * データベースに接続し、SQL 文をデータベースに送るための Statement オブジェクトを生成します。
  *
  *@return    新しいデフォルト Statement オブジェクト
  *@exception  SQLException  データベースアクセスエラーが発生した場合、このメソッドがクローズされた接続に対して呼び出された場合、または指定されたパラメータが型および並行処理を示す ResultSet 定数でない場合 
  */
  public Statement createStatement() throws SQLException{
    if (connect()){
      return con.createStatement();
    }
    return null;
  }
  
  /**
  * データベースに接続し、パラメータ付き SQL 文をデータベースに送るための PreparedStatement オブジェクトを生成します。  
  *
  *@param  sql  1 つ以上の '?' IN パラメータプレースホルダーを含めることができる SQL 文 
  *@return    プリコンパイルされた SQL 文を含む新しいデフォルトの PreparedStatement オブジェクト 
  *@exception  SQLException  データベースアクセスエラーが発生した場合、またはこのメソッドがクローズされた接続について呼び出された場合 
  */
  public PreparedStatement prepareStatement(String sql) throws SQLException {
    if (connect()){
      return con.prepareStatement(sql);
    }
    return null;
  }
  
  /**
  * データベースのストアドプロシージャーを呼び出すための CallableStatement オブジェクトを生成します
  *
  *@param  sql - 1 つ以上の '?' パラメータプレースホルダーを含めることができる SQL 文。 通常この文は、JBDC 呼び出しのエスケープ構文を使用して指定される
  *@return    プリコンパイルされた SQL 文を含む新しいデフォルトの CallableStatement オブジェクト
  *@exception  SQLException  データベースアクセスエラーが発生した場合、またはこのメソッドがクローズされた接続について呼び出された場合 
  */
  public CallableStatement prepareCall(String sql) throws SQLException {
    if (connect()){
      return con.prepareCall(sql);
    }
    return null;
  }
  
  /**
  * 指定された Statmentクラス インスタンスを解放します。  
  *
  *@param  st  Statmentクラス インスタンス
  */
  public void close(Statement st){
    if (st != null){
      try {
        st.close();
      } catch (Exception e){
        this.outputException(e);
      }
    }
  }
  
  /**
  * 指定された ResultSetクラス インスタンスを解放します。  
  *
  *@param  rs  ResultSetクラス インスタンス
  */
  public void close(ResultSet rs){
    if (rs != null){
      try {
        rs.close();
      } catch (Exception e){
        this.outputException(e);
      }
    }
  }
  
  /**
  * 指定された Statmentクラス インスタンス と ResultSetクラス インスタンス を解放します。  
  *
  *@param  st  Statmentクラス インスタンス
  *@param  rs  ResultSetクラス インスタンス
  */
  public void close(Statement st, ResultSet rs){
    close(rs);
    close(st);
  }
  
  /**
  * コミット処理をする
  *
  *@return    コミット処理に成功した場合はTrue、それ以外はFalse。
  */
  public boolean commit() {
    if (isClosed()) {
      return false;
    }
    
    try {
      con.commit();
      return true;
    } catch (Exception e) {
      this.outputException(e);
      return false;
    }
  }
  
  
  
  /**
  *  データベース接続
  *
  *@return    接続に成功した場合はTrue、それ以外はFalse。
  */
  public boolean connect() throws SQLException{
    boolean result = false;
    if (isClosed()) {
      con = DriverManager.getConnection(connectionString,
        user, pass);
      con.setAutoCommit(false);
      result = true;
    } else {
      // Log.getLogger().severe("既に接続されています");
      result = true;
    }
    return result;
  }
  
  
  /**
  *  指定されたパラメータからDBAccessorインスタンスを返す。
  *  getInstance() を使用することにより、生成された
  *  インスタンスを取り出すことが出来る。<br><br>
  *  もし、以前に生成されたインスタンスがあれば接続を閉じる。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@return                   生成したDBAccessorのインスタンス
  */
  public static DBAccessor createInstance(String driverName, String connectionString, String user, String pass) {
    return createInstance(driverName, connectionString, user, pass, TO_CONSOLE);
  }
  
  /**
  *  指定されたパラメータからDBAccessorインスタンスを返す。
  *  getInstance() を使用することにより、生成された
  *  インスタンスを取り出すことが出来る。<br><br>
  *  もし、以前に生成されたインスタンスがあれば接続を閉じる。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  *@return                   生成したDBAccessorのインスタンス
  */
  public static DBAccessor createInstance(String driverName, String connectionString, String user, String pass, int errorLog) {
    if (self != null && !self.isClosed()){
      self.close();
    }
    self = new DBAccessor(driverName, connectionString, user, pass, errorLog);
    return getInstance();
  }
  
  
  
  /**
  *  createInstance()メソッドによって生成されたインスタンスを
  *  取得する。
  *
  *@return    createInstanceによって生成されたDBAccessorインスタンス
  */
  public static DBAccessor getInstance() {
    return self;
  }
  
  
  /**
  *  createInstance()メソッドによって生成されたインスタンスから
  *  新しいDBAccessorを返す
  *
  *@return    createInstanceによって生成されたDBAccessorインスタンスから
  *           生成された新しいDBAccessor
  */
  public static DBAccessor newInstance() {
    return (DBAccessor)getInstance().clone();
  }
  
  
  /**
  *  接続状態を返す。
  *
  *@return    閉じている場合はTrue。
  */
  public boolean isClosed() {
    try {
      return (con == null || con.isClosed());
    } catch (Exception e) {
      this.outputException(e);
      return true;
    }
    
  }
  
  
  /**
  * ロールバック処理をする
  *
  *@return    Description of the Return Value
  */
  public boolean rollback() {
    if (isClosed()) {
      return false;
    }
    
    try {
      con.rollback();
      return true;
    } catch (Exception e) {
      this.outputException(e);
      return false;
    }
  }
  
  /**
  * 指定された Exceptionクラス インスタンスよりエラーを出力します。
  *
  *@param  e  Exceptionクラス インスタンス
  */
  private void outputException(Exception e){
    switch (errorLog) {
    case TO_LOG:
      //Log.logStackTrace(e);
      break;
    case TO_CONSOLE:
      System.out.println(e);
      break;
    case TO_NO:
      break;
    case TO_DIALOG:
      javax.swing.JOptionPane.showMessageDialog(null, e);
      break;
    }
  }
  
  /**
  * 指定されたエラーの出力先をセットします。
  *
  *@param  errorLog  エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  */
  public void setErrorLog(int errorLog){
    this.errorLog = errorLog;
  }
  
  /**
  * データベースのコネクションを返します。 
  * 
  *@return    データベースコネクション
  */
  public Connection getConnection() throws SQLException{
    if (connect()){
      return con;
    }
    return null;
  }
  
  /**
  * パラメータの型に合わせて PreparedStatement にパラメータをセットする。
  * 
  *@param  st             PreparedStatementインスタンス
  *@param  param          パラメータのArrayList
  *@exception  Exception  処理中に発生した例外
  */
  public void setParameters(PreparedStatement st, ArrayList<Object> param) throws Exception {
    setParameters(st, param.toArray());
  }
  
  /**
  * パラメータの型に合わせて PreparedStatement にパラメータをセットする。
  * 
  *@param  st             PreparedStatementインスタンス
  *@param  param          パラメータのObject配列
  *@exception  Exception  処理中に発生した例外
  */
  public void setParameters(PreparedStatement st, Object[] param) throws Exception {
    for (int i = 0; i < param.length; i++) {
      if (param[i] instanceof Long){
        st.setLong(i + 1, (Long)param[i]);
      } else if (param[i] instanceof Double){
        st.setDouble(i + 1, (Double)param[i]);
      } else if (param[i] instanceof Integer){
        st.setInt(i + 1, (Integer)param[i]);
      } else if (param[i] instanceof java.sql.Date){
        st.setDate(i + 1, (java.sql.Date)param[i]);
      } else {
        st.setString(i + 1, (String)param[i]);
      }
    }
  }
  
  /** 
  * 指定されたSQLを実行し、実行結果を ArrayList で返す。
  * 
  * @param sql 実行する SQL文
  * @param mode 戻り値のモード。ALL の場合は全件、ONE の場合は最初の1件を返す。
  */
  public ArrayList<HashMap> executeQuery(String sql, MODE mode) throws Exception {
    if (!connect()){
      return null;
    }
    
    PreparedStatement st = con.prepareStatement(sql);
    ArrayList<Object> args = new ArrayList<Object>();
    return executeQuery(st,args, mode);
  }
  
  /** 
  * 指定された PreparedStatement を実行し、実行結果を ArrayList で返す。
  * 
  * @param st 実行する PreparedStatement
  * @param args PreparedStatement の引数。必要ない場合は null。 
  * @param mode 戻り値のモード。ALL の場合は全件、ONE の場合は最初の1件を返す。
  */
  public ArrayList<HashMap> executeQuery(PreparedStatement st, ArrayList<Object> args, MODE mode) throws Exception {
    ResultSet rs = null;
    ArrayList<HashMap> rows = null;
    
    try {
      if (args == null){
        args = new ArrayList<Object>();
      }
      
      
      ResultSetMetaData rsmd = null;
      setParameters(st,args);
      
      rs = st.executeQuery();
      rsmd = rs.getMetaData();
      
      int colCnt = rsmd.getColumnCount();
      String colLabel = "";
      rows = new ArrayList<HashMap>();
      while(rs.next()){
        HashMap<Object,Object> row = new HashMap<Object,Object>();
        for (int i = 0; i < colCnt; i++){
          colLabel = rsmd.getColumnLabel(i+1);
          row.put(colLabel,rs.getObject(colLabel));
        }
        rows.add(row);
        
        if (mode == MODE.ONE){
          break;
        }
      }
      return rows;
    } finally {
      close(st,rs);
    }
  }
}

DBPoolManager

DBAccessorをプールするクラス。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
import java.util.*;

public class DBPoolManager {
  /**  接続文字列(URL) */
  private String connectionString = null;
  /**  ドライバ名 */
  private String driverName = null;
  /**  パスワード */
  private String pass = null;
  /**  ユーザ名 */
  private String user = null;
  /** エラー時にログの出力先 */
  protected int errorLog = DBAccessor.TO_CONSOLE;
  
  /** ロックオブジェクト */
  private byte[] lock = new byte[0];
  /** プール */
  private HashStack<DBAccessor> pool;
  /** 管理しているすべてのオブジェクト  */
  private HashSet<DBAccessor> allList;
  /** 自動クローズ処理用タイマー */
  private Timer closeTimer;
  /** 最後に使用されてから自動クローズするまでの時間 */
  private long closeTime;
  /** 最後に使用されてから自動クローズするまでの時間 のデフォルト値 */
  final static private long DEFAULT_DELAY = 1000 * 60 * 60;
  /** 自分自身のオブジェクト */
  private static DBPoolManager self = null;
  
  
  /**
  * コンストラクタ。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  */
  public DBPoolManager(String driverName, String connectionString, String user, String pass, int poolSize) {
    this(driverName, connectionString, user, pass, DBAccessor.TO_CONSOLE,poolSize);
  }
  
  
  /**
  * コンストラクタ。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  *@param  poolSize          プールのサイズ
  */
  public DBPoolManager(String driverName, String connectionString, String user, String pass, int errorLog, int poolSize) {
    this(driverName, connectionString, user, pass, DBAccessor.TO_CONSOLE,poolSize, DEFAULT_DELAY);
  }
  
  
  /**
  * コンストラクタ。
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  *@param  poolSize          プールのサイズ
  *@param  closeTime        使用していないコネクションを閉じるまでの時間(ミリ秒)
  */
  public DBPoolManager(String driverName, String connectionString, String user, String pass, int errorLog, int poolSize, long closeTime) {
    
    this.driverName = driverName;
    this.connectionString = connectionString;
    this.user = user;
    this.pass = pass;
    this.errorLog = errorLog;
    this.closeTime = closeTime;
    
    if (poolSize < 1){
      poolSize = 10;
    }
    pool = new HashStack<DBAccessor>();
    for(int i = 0; i < poolSize; i++){
      pool.push(null);
    }
    allList = new HashSet<DBAccessor>();
    startTimer(closeTime / 10);
  }
  
  
  /**
  * プールされているコネクションを自動的に
  * クローズするためのタイマーを開始する
  * 
  *@param  delay  コネクションを自動的に閉じるまでの時間
  */
  public void startTimer(long delay){
    if (this.closeTimer != null){
      stopTimer();
    }
    this.closeTimer = new Timer();
    TimerTask task = new TimerTask(){
      @Override
      public void run(){
        closeNotUsed();
      }
    };
    this.closeTimer.schedule(task, delay, delay);
  }
  
  
  /**
  * プールされているコネクションを自動的に
  * クローズするためのタイマーを止める 
  */
  public void stopTimer(){
    if (this.closeTimer != null){
      this.closeTimer.cancel();
      this.closeTimer = null;
    }
  }
  
  
  /**
  * 管理しているコネクションをすべて閉じて、
  * メモリを開放する 
  */
  public void dispose(){
    closeAll();
    stopTimer();
  }
  
  
  /**
  *  指定されたパラメータからDBAccessorインスタンスを返す。
  *  getInstance() を使用することにより、生成された
  *  インスタンスを取り出すことが出来る。<br><br>
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  poolSize          プールのサイズ
  */
  public static DBPoolManager createInstance(String driverName, String connectionString, String user, String pass, int poolSize) {
    return createInstance(driverName, connectionString, user, pass, DBAccessor.TO_CONSOLE, poolSize);
  }
  
  
  /**
  *  指定されたパラメータからDBAccessorインスタンスを返す。
  *  getInstance() を使用することにより、生成された
  *  インスタンスを取り出すことが出来る。<br><br>
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  *@param  poolSize          プールのサイズ
  */
  public static DBPoolManager createInstance(String driverName, String connectionString, String user, String pass, int errorLog, int poolSize) {
    return createInstance(driverName, connectionString, user, pass, DBAccessor.TO_CONSOLE, poolSize, DEFAULT_DELAY);
  }
  
  
  /**
  *  指定されたパラメータからDBAccessorインスタンスを返す。
  *  getInstance() を使用することにより、生成された
  *  インスタンスを取り出すことが出来る。<br><br>
  *
  *@param  driverName        DBドライバ名
  *@param  connectionString  DB接続文字列(URL)
  *@param  user              ユーザー名
  *@param  pass              パスワード
  *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
  *@param  poolSize          プールのサイズ
  *@param  closeTime        使用していないコネクションを閉じるまでの時間(ミリ秒)
  */
  public static DBPoolManager createInstance(String driverName, String connectionString, String user, String pass, int errorLog, int poolSize, long closeTime) {
    if (self != null){
      self.dispose();
    }
    self = new DBPoolManager(
      driverName,
      connectionString,
      user,
      pass,
      errorLog,
      poolSize,
      closeTime);
    return getInstance();
  }
  
  
  /**
  *  createInstance()メソッドによって生成されたインスタンスを
  *  取得する。
  *
  *@return    createInstanceによって生成された DBPoolManager インスタンス
  */
  public static DBPoolManager getInstance() {
    return self;
  }
  
  
  /**
  * DBAccessor を返す。 
  * 
  *@return    DBAccessor
  */
  public DBAccessor getDBAccessor(){
    synchronized(lock){
      // System.out.println("get " + Thread.currentThread());
      while(pool.empty()){
        try {
          // System.out.println("lock " + Thread.currentThread());
          lock.wait();
        } catch (Exception e){
        }
      }
      // System.out.println("get2 " + Thread.currentThread());
      DBAccessor db = pool.pop();
      if (db == null){
        db = new DBAccessorForPool(
          this,
          driverName,
          connectionString,
          user,
          pass,
          errorLog
          );
        allList.add(db);
      }
      return db;
    }
  }
  
  
  /**
  * DBAccessor をプールへ戻す 
  * 
  *@param  db  プールへ戻す DBAccessor
  */
  private void pushDBAccessor(DBAccessor db){
    synchronized(lock){
      // System.out.println("push " + Thread.currentThread());
      if (allList.contains(db) && !pool.contains(db)){
        pool.push(db);
        // System.out.println("notify " + Thread.currentThread());
        lock.notify();
      }
    }
  }
  
  
  /**
  * 管理しているコネクションをすべて閉じる 
  * 
  */
  private void closeAll(){
    for(DBAccessor db : allList){
      if (db instanceof DBAccessorForPool){
        ((DBAccessorForPool)db).closeConnection();
      } else {
        db.close();
      }
    }
  }
  
  
  /**
  * 使用されていないコネクションを閉じる 
  * 
  */
  private void closeNotUsed(){
    synchronized(lock){
      Iterator<DBAccessor> iterator = pool.iterator();
      long nowTime = System.currentTimeMillis();
      
      while(iterator.hasNext()){
        DBAccessor dba = iterator.next();
        if (dba != null && !dba.isClosed() && dba instanceof DBAccessorForPool){
          DBAccessorForPool dbafp = (DBAccessorForPool)dba;
          long lastUseTime = dbafp.getLastUseTime();
          if ( nowTime - lastUseTime > closeTime ){
            dbafp.closeConnection();
          }
        }
      }
    }
  }
  
  
  
  static class HashStack<T> {
    private HashSet<T> set;
    private Stack<T> stack;
    
    public HashStack(){
      set = new HashSet<T>();
      stack = new Stack<T>();
    }
    
    public void push(T t){
      set.add(t);
      stack.push(t);
    }
    
    public T pop(){
      T t = stack.pop();
      set.remove(t);
      return t;
    }
    
    public int size(){
      return set.size();
    }
    
    public Iterator<T> iterator() {
      return set.iterator();
    }
    
    public boolean contains(T t){
      return set.contains(t);
    }
    
    public boolean empty(){
      return stack.empty();
    }
  }
  
  
  
  static class DBAccessorForPool extends DBAccessor {
    private DBPoolManager manager;
    private long lastUseTime;
    
    /**
    * コンストラクタ。
    *
    *@param  driverName        DBドライバ名
    *@param  connectionString  DB接続文字列(URL)
    *@param  user              ユーザー名
    *@param  pass              パスワード
    *@param  errorLog          エラーの出力先。TO_NO、TO_CONSOLE、TO_LOG、TO_DIALOGのいずれか
    */
    public DBAccessorForPool(DBPoolManager manager, String driverName, String connectionString, String user, String pass, int errorLog) {
      super(driverName, connectionString, user, pass, DBAccessor.TO_CONSOLE);
      this.manager = manager;
      this.lastUseTime = System.currentTimeMillis();
    }
    
    private void closeConnection(){
      super.close();
    }
    
    @Override
    public void close(){
      rollback();
      this.lastUseTime = System.currentTimeMillis();
      manager.pushDBAccessor(this);
    }
    
    public long getLastUseTime(){
      return lastUseTime;
    }
  }
}
[カテゴリ: プログラミング言語 > Java]



  • Hatenaブックマークに追加
  • livedoorクリップに追加
  • del.icio.usに追加
  • FC2ブックマークに追加

最終更新時間:2013年11月04日 18時01分27秒