Connection Pooling

데이터베이스에 대한 Connection을 관리하는 것은 매우 바람직한 일입니다.
프로그램내에서 데이터베이스에 연결을 시도하는 것(Connection 객체를 얻는것)은 시간이 많이 걸리는 작업이기 때문입니다.
그럼에도 지금까지 우리는 Connection 을 얻은 후 사용 후 바로 자원을 반납했습니다.
만약, 일정량의 Connection 을 미리 생성시켜 free Connection list 이란 저장소를 만들어서 저장했다가 프로그램에서 호출이 있으면 free Connection list 중에서 Connection 제공하고, 일이 끝나면 free Connection list 로 다시 저장한다면 Connection 객체를 생성하기 위한 시간을 절약할 수 있을 겁니다.
바로 이 기법이 Connection Pooling 입니다.

전체 클래스 요약
Connection Pooling 관련 소스
사용법

1. 전체 클래스 요약

Log.java
로그 파일에 로그 메시지를 입력하기 위한 클래스

DBConnectionPool.java
특정 데이터베이스에 대한 커넥션 객체를 풀로 관리하는 커넥션풀 클래스
DBConnectionPoolManager.java
커넥션풀 객체들을 관리하는 클래스

ConnectionManager.java
DBConnectionPoolManager 클래스에게 커넥션을 요청하는 클래스
여러 데이터베이스를 고려한 추상클래스
데이터베이스에 따라 이 클래스를 상속하는 클래스를 작성

OracleConnectionManager.java
오라클용 커넥션을 얻기위해 ConnectionManager 클래스를 상속해서 구현한 클래스

oracle.properties
오라클용 커넥션풀 설정 파일
oracle.properties 에서 "oracle" 이란 문자열은 오라클용 커넥션풀 객체를 구별하는 이름으로 사용된다.
설정 내용을 코드가 아닌 파일에 저장하면 관리하기가 쉽다.

2. Connection Pooling 관련 소스

Log.java

package net.java_school.util;

import java.io.*;
import java.util.Date;

public class Log {
  
  public String dbgFile = "D:\\jdbc\\error.txt"; // 윈도우  계열
  //public String dbgFile = "/jdbc/error.dbg"; // 유닉스 계열
  FileWriter fw = null;
  
  public Log() {
    super();
    try {
      fw = new FileWriter( dbgFile, true );
    } catch ( IOException e ){}
  }

  public void close() {
    try {
      fw.close();
    } catch ( IOException e ){}
  }

  public void close( FileWriter fw ) {
    try {
      fw.close();
    } catch ( IOException e ){}
  }

  public void debug( String msg ) {
    try {
      fw.write( new java.util.Date()+ " : " );
      fw.write( msg + " \r\n" );
      fw.flush();
    } catch ( IOException e ) {
      System.err.println( "IOException.......!!" );
    }
  }

  public static void out( String msg ) {
    System.out.println( new Date() + ": " + msg );
  }

  public static void err( String msg ) {
    System.out.println( new Date() + ": " + msg );
  }

  public static void err( Throwable e, String msg ) {
    System.err.println( new Date() + ": " + msg );
    e.printStackTrace( System.out );
  }
}

DBConnectionPool.java

package net.java_school.db.dbpool; 

import java.util.*; 
import java.sql.*; 
import java.util.Date; 
import net.java_school.util.Log;

// Connection Pool을 관리하는 클래스 
class DBConnectionPool {
  
  // 현재 사용 중인 Connection 개수
  private int checkedOut;
  
  // Free Connection List JDK 1.5 이후버전일 경우
  private Vector<Connection> freeConnections = new Vector<Connection>();

  // Free Connection List JDK 1.5 이전버전일 경우
  // private Vector freeConnections = new Vector();

  // Connection 최대 개수
  private int maxConn;
  
  // Connection 초기 개수
  private int initConn;
  
  // Waiting time (pool에 connection이 없을때 기다리는 최대시간)
  private int maxWait;
  
  // Connection Pool Name
  private String name;
  
  // DB Password
  private String password;
  
  // DB URL
  private String URL;
  
  // DB UserID
  private String user;
  
  // Constructor
  public DBConnectionPool( String name, String URL, String user, String password, 
    int maxConn, int initConn, int waitTime ) {
    this.name = name;
    this.URL = URL;
    this.user = user;
    this.password = password;
    this.maxConn = maxConn;
    this.maxWait = waitTime;
    
    for ( int i = 0; i < initConn; i++ ) {
      freeConnections.addElement( newConnection() );
    }
  }

  // Connection 반납
  // @param con : 반납할 Connection
  public synchronized void freeConnection( Connection con ) {
    freeConnections.addElement( con );
    checkedOut--;
    // Connection을 얻기 위해 대기하고 있는 thread에 알림
    notifyAll();
  }

  // Connection 을 얻음
  public synchronized Connection getConnection() {
    Connection con = null;
    // Connection이 Free List에 있으면 List의 처음 것을 얻음
    if ( freeConnections.size() > 0 ) {
      con = (Connection) freeConnections.firstElement();
      freeConnections.removeElementAt(0);
      try {
        // DBMS에 의해 Connection이 close 되었으면 다시 요구
        if ( con.isClosed() ) {
          Log.err( "Removed bad connection from " + name );
          con = getConnection();
        }
      } // 요상한 Connection 발생하면 다시 요구
      catch ( SQLException e ) {
        Log.err( e, "Removed bad connection from " + name );
        con = getConnection();
      }
    } // Connection이 Free List에 없으면 새로 생성
    else if ( maxConn == 0 || checkedOut < maxConn ) {
      con = newConnection();
    }
    
    if ( con != null ) {
      checkedOut++;
    }
    return con;
  }

  // Connection을 얻음
  // @param timeout : Connection을 얻기 위한 최대 기다림 시간
  public synchronized Connection getConnection( long timeout ) {
    long startTime = new Date().getTime();
    Connection con;
    while ( (con = getConnection()) == null ) {
      try {
        wait( timeout * maxWait );
      } catch ( InterruptedException e ) {}
      if ( (new Date().getTime() - startTime) >= timeout ) {
        // 기다림 시간 초과
        return null;
      }
    }
    return con;
  }

  // Connection 생성
  private Connection newConnection() {
    Connection con = null;
    try {
      if ( user == null ) {
        con = DriverManager.getConnection( URL );
      } else {
        con = DriverManager.getConnection( URL, user, password );
      }
      Log.out( "Created a new connection in pool " + name );
    } catch ( SQLException e ) {
      Log.err(e, "Can't create a new connection for " + URL + " user : " +
        user + " passwd : " + password);
      return null;
    }
    return con;
  }
}

DBConnectionPoolManager.java

package net.java_school.db.dbpool;

import java.sql.*;
import java.util.*;
import net.java_school.util.Log;

public class DBConnectionPoolManager {
  
  // 인스턴스를 하나만 유지하기 위해 static 으로 선언
  static private DBConnectionPoolManager instance = null;
  
  //JDBC 드라이버 관리 JDK 1.5 이상인 경우
  private Vector<String> drivers = new Vector<String>();
  //JDBC 드라이버 관리 JDK 1.5 이하인 경우
  //private Vector drivers = new Vector();

  // DB Connection Pool List JDK 1.5 이상의 경우
  private Hashtable<String,DBConnectionPool> pools = 
  	new Hashtable<String,DBConnectionPool>();
  // DB Connection Pool List JDK 1.5 이하의 경우
  // private Hashtable pools = new Hashtable();

  // DBConnectionPoolManager의 instance를 얻음
  // @return DBConnectionManger
  static synchronized public DBConnectionPoolManager getInstance() {
    if ( instance == null ) {
      instance = new DBConnectionPoolManager();
    }
    return instance;
  }

  // Default Constructor
  private DBConnectionPoolManager() {}

  // 현재 Connection을 Free Connection List로 보냄
  // @param name : Pool Name
  // @param con : Connection
  public void freeConnection( String name, Connection con ) {
    DBConnectionPool pool = (DBConnectionPool) pools.get( name );
    if ( pool != null ) {
      pool.freeConnection(con);
    }
    Log.out( "One Connection of " + name + " was freed" );
  }

  // Open Connection을 얻음. 현재 열린 커넥션이 없고 최대 커넥션 개수가
  // 사용 중이 아닐 때는 새로운 커넥션을 생성. 현재 열린 커넥션이 없고
  // 최대 커넥션 개수가 사용 중일 때 기본 대기 시간을 기다림
  // @param name : Pool Name
  // @return Connection : The connection or null
  public Connection getConnection( String name ) {
    DBConnectionPool pool = (DBConnectionPool) pools.get( name );
    if ( pool != null ) {
      return pool.getConnection(10);
    }
    return null;
  }

  // Connection Pool을 생성
  // @param poolName : 생성할 Pool Name
  // @param url : DB URL
  // @param user : DB UserID
  // @param password : DB Password
  private void createPools( String poolName, String url, String user, 
    String password, int maxConn, int initConn, int maxWait ) {
    DBConnectionPool pool = new DBConnectionPool( poolName, url, user,
      password, maxConn, initConn, maxWait );
    pools.put( poolName, pool );
    Log.out( "Initialized pool " + poolName );
  }

  // 초기화 작업
  public void init( String poolName, String driver, String url,
    String user, String passwd, int maxConn, int initConn, int maxWait ) {
    loadDrivers( driver );
    createPools( poolName, url, user, passwd, maxConn, initConn, maxWait );
  }

  // JDBC Driver Loading
  // @param driverClassName : 사용하고자 하는 DB의 JDBC 드라이버
  private void loadDrivers( String driverClassName ) {
    try {
      Class.forName( driverClassName );
      drivers.addElement( driverClassName );
      Log.out( "Registered JDBC driver " + driverClassName );
    } catch ( Exception e ) {
      Log.err( e, "Can't register JDBC driver: " + driverClassName );
    }
  }

  public Hashtable<String,DBConnectionPool> getPools() {
    return pools;
  }

  public int getDriverNumber() {
    return drivers.size();
  }
}

ConnectionManager.java

package net.java_school.db.dbpool;

import java.sql.*;
import java.io.*;
import java.util.*;
import net.java_school.util.Log;

public abstract class ConnectionManager {

  protected DBConnectionPoolManager connMgr = null;
  protected String poolName, dbServer, dbName, port, userID, passwd;
  int maxConn,initConn, maxWait;
  private Properties dbProperties;
  private String configFile;

  public ConnectionManager( String poolName ) {
    this.poolName = poolName;
    // Property파일 디렉토리 지정
    configFile = "D:\\jdbc\\"+poolName+".properties";
    try {
      dbProperties = readProperties();
      dbServer = getProperty( "dbServer" );
      port = getProperty( "port" );
      dbName = getProperty( "dbName" );
      userID = getProperty( "userID" );
      passwd = getProperty( "passwd" );
      maxConn = Integer.parseInt( getProperty( "maxConn" ) );
      initConn = Integer.parseInt( getProperty( "initConn" ) );
      maxWait = Integer.parseInt( getProperty( "maxWait" ) );
    } catch( IOException ioe ) {
      Log.err( "Error reading properties of " + configFile );
    }
  }

  public Connection getConnection() {
    return ( connMgr.getConnection( poolName ) );
  }

  public void freeConnection( Connection conn ) {
    connMgr.freeConnection( poolName, conn );
  }

  private String getProperty( String prop ) throws IOException {
    return ( dbProperties.getProperty( prop ) );
  }

  protected synchronized Properties readProperties() throws IOException {
    Properties tempProperties = new Properties();
    FileInputStream in = new FileInputStream( configFile );
    tempProperties.load( in );
    return tempProperties;
  }

  public int getDriverNumber() {
    return connMgr.getDriverNumber();
  }
}

OracleConnectionManager.java

package net.java_school.db.dbpool;

public class OracleConnectionManager extends ConnectionManager {
  public OracleConnectionManager() {
    super( "oracle" );
    String JDBCDriver = "oracle.jdbc.driver.OracleDriver";
    
    // 오라클용 JDBC thin driver
    String JDBCDriverType = "jdbc:oracle:thin";
    
    String url = JDBCDriverType + ":@" + dbServer + ":" + port + ":" + dbName;
    
    connMgr = DBConnectionPoolManager.getInstance();
    connMgr.init( poolName, JDBCDriver, url, userID, passwd, maxConn, initConn, maxWait );
  }
}

oracle.properties

############################################ 
# Database Connection Properties for Oracle
############################################ 

# Database Server Name OR IP address 
dbServer = 127.0.0.1

# The port number your DB server listents to. 
port = 1521

# Database Name 
dbName = orcl

# Database User 
userID = scott

# Database Password 
passwd = tiger

# Maximum Connection Number 
maxConn = 20

# Inital Connection Number 
initConn = 5

# Maximum Wait Time 
maxWait = 5

3. 사용법

먼저 위의 소스를 전부 적당한 디렉토리에 넣고 ( 예 D:\jdbc ) javac -d . *.java 로 컴파일합니다.
아래부터는 D:\jdbc 를 기준으로 설명합니다.
Log.java 소스에서
public String dbgFile = "D:\\jdbc\\error.txt"; 에 맞게 D:\jdbc 에 error.txt 라는 내용이 빈 파일을 만들어 놓습니다.
ConnectionManager.java 소스에서
configFile = "D:\\jdbc\\"+poolName+".properties"; 에 맞게 orcale.properties 파일을 D:\jdbc 에 위치시킵니다.
이제 D:\jdbc 디렉토리를 CLASSPATH에 추가합니다.
새 명령 프롬프트를 띄워서 set classpath 로 확인합니다.

C:\Documents and Settings\Administrator>set classpath
CLASSPATH=.;F:\oracle\product\10.2.0\db_1\jdbc\lib\classes12.jar;D:\jdbc

C:\Documents and Settings\Administrator>

Connection Pooling 이용은 지금까지 해온 순수 자바 애플리케이션으로 예제를 구현하기기 힘듭니다.
Servlets 이나 JSP 에서 실제 예제에서 다루겠습니다.
이것으로 JDBC Tutorial 를 마침니다.

이전 강좌 : 트랜잭션