[유용한 Database Connection Pool 관련 java 코드 3-연재] Database Connection Manager java class WCDBConnectionManager.java

지난번 글에서 database connection들을 관리하는 WCDBConnectionPool에 대해서 설명을 하였습니다.
WCDBConnectionPool은 하나의 database에 대한 connection들을 관리하는 class입니다.
이번에는 여러개의 database에 대한 connection 관리하기 위해서
connection pool을 관리하는 class 즉 WCDBConnectionPool을 여러개 관리하는 class에
대해서 설명하겠습니다.

WCDBConnectionManager.java

이 class는 여러개의 WCDBConnectionPool을 관리합니다.
WCDBConnection.java 는 database Connection object를 저장하는 class입니다.
WCDBConnectionPool.java 는 하나의 database에서 여러개의 connection을 사용할 수 있도록 connection 들을 관리하는 pool입니다.
WCDBConnectionManager.java 는 database connection pool 여러개를 관리하는 class입니다.
WCStmt는 WCDBConnectionManager의 getConnection을 호출하여 Connection을 얻고 이를 사용하여 SQL을 처리하는 class 입니다.

즉 아래와 같은 구조입니다.

WDDBConnectionManager
-> WCDBConnectionPool : database AAA
    -> WCDBConnection -> Connection
    -> WCDBConnection -> Connection
-> WCDBConnectionPool : database BBB
    -> WCDBConnection -> Connection
    -> WCDBConnection -> Connection
WCStmt

WCDBConnectionManager에는 WCDBConnectionPool들을 저장하고 있습니다.
Hashtable m_htPool : WCDBConnectionPool들을 저장, connection pool의 이름은 database에 할당된 이름입니다.(Data Source Name)

WCDBConnectionManager이 생성될때 initDriver가 자동 호출되어 object를 초기화합니다.
initDriver() 초기화하면
  -> 환경변수 파일을 읽어서 정보를 얻어옴
  -> createPools : 환경설정파일에 기록된 database연결 정보를 사용하여 여러개의 WCDBConnectionPool 들을 생성
   -> createPool : 하나의 WCDBConnectionPool 생성
    -> createPoolObject : WCDBConnectionPool Object를 생성
    -> registerDriver : JDBC driver를 register
    -> Database 정보를 설정(userid,password,url등)

환경변수 파일은
C:\Program Files\Apache Software Foundation\Tomcat 5.0\webapps\ROOT\WEB-INF\classes\wdl\wdl.properties
입니다. 이것은 Tomcat 5.0이라는 가정입니다.

-- 환경변수 파일 내용 시작
WDLDatabasePool.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
WDLDatabasePool.drivers=org.gjt.mm.mysql.Driver
WDLDatabasePool.dsn=WDLDatabasePool
WDLDatabasePool.user=root
WDLDatabasePool.password=
WDLDatabasePool.maxconn=50
WDLDatabasePool.databasetype=mysql
WDLDatabasePool.timeout=1000000
-- 환경변수 파일 내용 끝

환경변수 파일을 사용하지 않고 API를 사용하여 database connection pool을 생성하고
database connection을 얻어서 SQL을 실행하고 connection을 release할 수 있습니다.
아래의 WCProperties는 java의 Properties라고 생각하면 쉬울것 같습니다.
(WCProperties는 추후 다시 설명하겠습니다.)

-- 사용방법 sample code 시작
WCProperties rRcd = new WCProperties();
String sDsn = "WDLDatabasePool";
rRcd.setValue(sDsn+".url","jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8");
rRcd.setValue(sDsn+".drivers","org.gjt.mm.mysql.Driver");
rRcd.setValue(sDsn+".dsn","WDLDatabasePool");
rRcd.setValue(sDsn+".user","root");
rRcd.setValue(sDsn+".password","");
rRcd.setValue(sDsn+".maxconn","50");
rRcd.setValue(sDsn+".databasetype","mysql");
WCDBConnectionManager.getInstance().createPool(sDsn,rRcd);

WCDBConnection oDBConn = WCDBConnectionManager.getInstance().getConnection(sDsn);
if (oDBConn == null)
return;
Connection oConn = oDBConn.getConnection();
...RUN SQL...
WCDBConnectionManager.getInstance().freeConnection(oDBConn);
-- 사용방법 sample code 끝

WCDBConnection oDBConn = WCDBConnectionManager.getInstance().getConnection(sDsn);
이렇게 호출하여 database connection을 얻어옵니다.

getConnection(DatabaseName);
-> getConnectionPool(DatabaseName);
-> WCDBConnectionPool의 getConnection을 호출하여 connection을 얻어옵니다.

freeConnection(DatabaseName);
-> getConnectionPool(DatabaseName);
-> freeConnection(connection);

WCDBConnectionManager class에서 제공하는 또 다른 기능으로
database connection 초기화 입니다.
database 관련 application을 개발하는 과정에서 흔히 격는 일 중에 deadlock 상황입니다.

update table set xxx where condition1
이와 같이 처리를 하고 있는데
다른 database connection에서
update table set yyy where condition2
이와 같이 동시에 table에 대한 자료를 update한다고 하겠습니다.
그런데 첫번째 SQL을 실행하고 실수로 commit을 하지 않았고
두번째 SQL을 또 다른 database connection에서 실행한다고 하겠습니다.
두번째 SQL은 실행이 되지 않고 멈춰 있습니다.
deadlock 상황을 보다 정확히 설명하자면 한이 없기에 간단한 예를 들어보였습니다.
이와 같은 경우 어느 SQL이 문제가 되는지 알 수가 없습니다.
이러한 문제가 발생할때 가장 쉽게 해결하는 방법이 현재 실행중인 Connection을 모두
release하는 방법입니다. 물론 이것이 만능은 아닙니다.

WCDBConnectionManager.getInstance().init();
-> connection pool 각각에 대하여 release()를 호출;

이와 같이 모든 connection을 release하고 다시 connection pool을 생성하고
connection을 생성하면 일단 Web Server에 걸린 문제는 해결할 수 있습니다.
물론 근본적인 해결은 application을 수정해서 문제를 해결해야 할 것입니다.

WCDBConnection
WCDBConnectionPool
WCDBConnectionManager

이렇게 3개의 class에 대해서 설명을 하였습니다.

SQL을 실행하기 위해서는 Database Connection을 얻어온 다음에 여러가지 작업을
해야 합니다.

1. database connection을 생성
2. prepareStatement를 호출하고, fetch size 등을 설정하고
3. executeQuery를 실행하고
4. 결과를 얻어와서 저장하고
5. database connection을 free

이와 같이 SQL 실행을 처리하는 class가 WCStmt입니다.
WCStmt는 다음번에 설명하겠습니다.
환경변수 파일을 읽어서 loading하고 값을 얻어오는 방법은 추후에 다시 설명하겠습니다.

아래의 소스가 완벽히 돌기 위해서는 WCDBConnection,WCDBConnectionManager,WCStmt,WCProperties
,WCVector,WCLog,WCSystem 등의 source코드가 필요합니다.
이러한 소스코드도 모두 차차 글을 올리며 설명하겠습니다.
미리 보시려면 Web Development Library(www.webdevlib.net)에서 download 받아 사용하실 수 있습니다.

- 소스코드 WCDBConnectionManager.java 시작
package wdl;
import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;
import java.text.SimpleDateFormat;
public class WCDBConnectionManager
{
  public int m_nSeqNo = 0;
  static public WCDBConnectionManager m_instance = null;
  static public int m_clients;
  public PrintWriter m_log;
  public Hashtable m_htPool = new Hashtable();
  public boolean m_bInit = false;
  public WCDBConnectionManager()
  {
   m_nSeqNo = 0;
  }
  public PrintWriter getLog()
  {
   return m_log;
  }
  public int getPoolSize()
  {
   int nRet = m_htPool.size();
   return nRet;
  }
  public Hashtable getPools()
  {
   return m_htPool;
  }
  public static synchronized WCDBConnectionManager getInstance()
  {
   if (m_instance == null)
   {
    m_instance = new WCDBConnectionManager();
    m_instance.init();
   }
   m_clients ++;
   return m_instance;
  }
  public static synchronized void setInstance(WCDBConnectionManager oInstance)
  {
   m_instance = oInstance;
  }
  public void refreshEx()
  {
   releaseEx();
   init();
  }
  public void init()
  {
   releaseEx();
   initDriver();
  }
  public void initDriver()
  {
   try
   {
    WCEnv oEnv = WCEnv.getInstance();
    if (oEnv == null)
     return;
    WCProperties rEnv = oEnv.getProperties();
    String sDatabaseConnection = WCEnv.getInstance().getProperties().getStrValue("wdl.databaseConnection");
    WCCsvPsr oCsvPsr = new WCCsvPsr();
    Vector vsDatabaseConnectionName = oCsvPsr.parseString(sDatabaseConnection);
    createPools(rEnv,vsDatabaseConnectionName);
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.initDriver "+ex.toString());
    return;
   }
  }
  public WCDBConnectionPool createPoolObject(String sName,String sConnectionPoolClassName)
  {
   try
   {
    String sClassName = "wdl.WCDBConnectionPool";
    if (!WCString.isEmpty(sConnectionPoolClassName))
    {
     sClassName = sConnectionPoolClassName;
    }
    WCProperties rEnv = WCEnv.getInstance().getProperties();
    if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
    {
     WCLog.getInstance().printLog("WCDBConnectionManager.java createPool : dsn="+sName+",connection pool name="+sClassName+"");
    }
    WCDBConnectionPool oPool = (WCDBConnectionPool)Class.forName(sClassName).newInstance();
    oPool.setName(sName);
    return oPool;
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.createPool "+ex.toString());
   }
   return null;
  }
  public boolean isLoadedDriver(String sPoolName)
  {
   try
   {
    if (WCString.isEmpty(sPoolName))
    {
     return false;
    }
    WCDBConnectionPool oPool = (WCDBConnectionPool)getConnectionPool(sPoolName);
    if (oPool != null)
     return true;
    return false;
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.isLoadedDriver "+ex.toString());
   }
   return false;
  }
  public void createPools(WCProperties rEnv,Vector vsDatabaseConnectionName)
  {
   try
   {
    if (m_htPool != null)
     m_htPool = null;
    m_htPool = new Hashtable();
    if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
    {
     WCLog.getInstance().printLog("WCDBConnectionManager.java createPools : creating database connection pools");
     WCPage.debugTraceVS(vsDatabaseConnectionName);
    }
    int nCount = WCVector.size(vsDatabaseConnectionName);
    for (int i=0;i<nCount;i++)
    {
     String sPoolName = WCVector.getStrAt(vsDatabaseConnectionName,i);
     if (WCString.isEmpty(sPoolName))
     {
      continue;
     }
     createPool(sPoolName,rEnv);
    }
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("WCDBConnectionManager.java createPools exception : "+ex.toString());
   }
  }
  public synchronized WCDBConnectionPool createPool(String sPoolName,WCProperties rEnv)
  {
   try
   {
    if (WCString.isEmpty(sPoolName))
    {
     return null;
    }
    if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
    {
     WCLog.getInstance().printLog("WCDBConnectionManager.java createPool : sPoolName="+sPoolName);
    }
    if (isLoadedDriver(sPoolName))
    {
     return null;
    }
    String url = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".url"));
    String sDriverName = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".drivers"));
    String sCharset = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".charset"));
    String sDatabaseType = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".databasetype"));
    String user = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".user"));
    String password = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".password"));
    String maxconn = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".maxconn", "0"));
    int nMaxConn = 0;
    nMaxConn = WCString.parseInt(maxconn);
    String sTimeout = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".timeout","0"));
    long nTimeout = WCString.parseLong(sTimeout);
    String sConnectionPoolClassName = WCString.nullCheck(rEnv.getStrValue(sPoolName + ".connectionPoolClassName"));
    WCDBConnectionPool oPool = createPoolObject(sPoolName,sConnectionPoolClassName);
    if (oPool != null)
    {
     Driver oDriver = oPool.registerDriver(sDriverName);
     if (oDriver == null)
     {
      if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
      {
       WCLog.getInstance().printLog("WCDBConnectionManager.java createPool : fail to register driver="+sDriverName);
      }
      return null;
     }
     oPool.init(url,user,password,nMaxConn);
     oPool.setDriverName(sDriverName);
     oPool.setCharset(sCharset);
     oPool.setDatabaseType(sDatabaseType);
     oPool.setMaxConn(nMaxConn);
     oPool.setTimeout(nTimeout);
     addPool(sPoolName,oPool);
     if (WCString.isEmpty(sDatabaseType))
     {
      if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
      {
       WCLog.getInstance().printLog("WCDBConnectionManager.java createPool : you have to set the database type for the database connection pool "+sPoolName+" in the file (wdl.properties) oracle,mysql,mssql");
      }
     }
     if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
     {
      WCLog.getInstance().printLog("WCDBConnectionManager.java createPool : succ to create the database connection pool name="+sPoolName+",uri="+url+",drivers="+sDriverName+",user="+ user+",password=" + password + ",maxconn=" + maxconn+",charset="+sCharset+",databasetype="+sDatabaseType);
     }
    }
    else if (oPool == null)
    {
     if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
     {
      WCLog.getInstance().printLog("WCDBConnectionManager.java createPool : fail to create the database connection pool name="+sPoolName+",className="+sConnectionPoolClassName);
     }
    }
    return oPool;
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("WCDBConnectionManager.java createPool exception : "+ex.toString());
   }
   return null;
  }
  public synchronized void addPool(String sPoolName,WCDBConnectionPool oPool)
  {
   if (m_htPool == null)
   {
    m_htPool = new Hashtable();
   }
   m_htPool.put(sPoolName,oPool);
  }
  public WCDBConnectionPool getConnectionPool(String sName)
  {
   try
   {
    if (sName == null)
     return null;
    WCDBConnectionPool oPool = (WCDBConnectionPool)m_htPool.get(sName);
    if (oPool == null)
    {
    }
    return oPool;
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.getConnectionPool "+ex.toString());
   }
   return null;
  }
  public WCDBConnection getConnection(String sDsn)
  {
   if (sDsn == null)
    return null;
   WCDBConnectionPool oPool = (WCDBConnectionPool) getConnectionPool(sDsn);
   if (oPool != null)
   {
    WCDBConnection oDBConn = oPool.getConnection();
    if (oDBConn != null)
    {
    }
    return oDBConn;
   }
   WCProperties rEnv = WCEnv.getInstance().getProperties();
   if (WCString.parseBoolean(rEnv.getStrValue("wdl.init.verbose")) == true)
   {
    WCLog.getInstance().printLog("WCDBConnectionManager.java getConnection : fail to create a DB connection for "+sDsn);
   }
   return null;
  }
  public Connection getConnection2(String sDsn)
  {
   if (sDsn == null)
    return null;
   WCDBConnection oDBConn = getConnection(sDsn);
   if (oDBConn == null)
    return null;
   Connection oConn = oDBConn.getConnection();
   try
   {
    oConn.setAutoCommit(true);
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.getConnection2 after setAutoCommit "+ex.toString());
   }
   return oConn;
  }
  public WCDBConnection getConnection(String name, long time)
  {
   WCDBConnectionPool oPool = (WCDBConnectionPool) getConnectionPool(name);
   if (oPool != null)
   {
    return oPool.getConnection(time);
   }
   return null;
  }
  public synchronized void freeConnection(String sDsn, WCDBConnection con)
  {
   try
   {
    if (sDsn == null || con == null)
     return;
    WCDBConnectionPool oPool = (WCDBConnectionPool) getConnectionPool(sDsn);
    if (oPool != null)
    {
     oPool.freeConnection(con);
    }
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.freeConnection "+ex.toString());
   }
  }
  public synchronized void freeConnection2(String sDsn, Connection con)
  {
   try
   {
    if (sDsn == null || con == null)
     return;
    try
    {
     con.commit();
    }
    catch (Exception ex)
    {
     WCLog.getInstance().printLog("exception at WCDBConnectionManager.freeConnection2 after commit "+ex.toString());
    }
    WCDBConnectionPool oPool = (WCDBConnectionPool) getConnectionPool(sDsn);
    if (oPool != null)
    {
     oPool.freeConnection2(con);
    }
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.freeConnection2 "+ex.toString());
   }
  }
  public synchronized String getUniqueTimestamp()
  {
   java.util.Date now = new java.util.Date();
   SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd_HHmmss");
   String sDate = sdf.format(now);
   int nSeqNo = getSeqNo();
   sDate += "_"+nSeqNo;
   return sDate;
  }
  public synchronized int getSeqNo()
  {
   m_nSeqNo ++;
   return m_nSeqNo;
  }
  public synchronized void release()
  {
   if (--m_clients != 0)
   {
    return;
   }
   releaseEx();
  }
  public synchronized void releaseEx()
  {
   Enumeration enumPools = m_htPool.elements();
   while (enumPools.hasMoreElements())
   {
    WCDBConnectionPool oPool = (WCDBConnectionPool) enumPools.nextElement();
    oPool.release();
   }
   m_htPool = new Hashtable();
  }
  public synchronized WCDBConnectionPool removePool(String sPoolName)
  {
   try
   {
    WCDBConnectionPool oPool = (WCDBConnectionPool)getConnectionPool(sPoolName);
    if (oPool == null)
     return null;
    WCDBConnectionPool oRemovePool = (WCDBConnectionPool)m_htPool.remove(sPoolName);
    if (oRemovePool != oPool)
    {
     WCLog.getInstance().printLog("WCDBConnectionManager fail to remove a connection pool="+sPoolName);
     return null;
    }
    else
    {
     oPool.release();
     return oPool;
    }
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.removePool "+ex.toString());
   }
   return null;
  }
  public void log(Throwable e, String msg)
  {
   if (m_log != null)
   {
    m_log.println(new Date() + ": " + msg);
   }
   e.printStackTrace(m_log);
  }
  public void setDebug()
  {
  }
  public String getConnectionStateString()
  {
   try
   {
    StringBuffer sBuf = new StringBuffer();
    Hashtable htPools = getPools();
    if (htPools == null)
    {
     WCLog.getInstance().printLog("at WCDBConnectionManager.getConnectionState1 htPools is null");
     return "";
    }
    Enumeration enumPools = htPools.elements();
    if (enumPools == null)
    {
     WCLog.getInstance().printLog("at WCDBConnectionManager.getConnectionState1 enumPools is null");
     return "";
    }
    while (enumPools.hasMoreElements())
    {
     WCDBConnectionPool oPool = (WCDBConnectionPool) enumPools.nextElement();
     if (oPool != null)
     {
      String sDriverName = oPool.getDriverName();
      String sUrl = oPool.getUrl();
      String sUser = oPool.getUser();
      String sPassword = oPool.getPassword();
      String sDsn = oPool.getName();
      sBuf.append("dsn="+sDsn+"\nurl="+sUrl+"\ndriver="+sDriverName+"\nuser="+sUser+"\npassword="+sPassword+"\n");
      sBuf.append("connections for dsn="+sDsn+"\n");
      sBuf.append("connection count="+oPool.getConnectionCount()+"\n");
      sBuf.append("free connection count="+oPool.getFreeConnectionCount()+"\n");
      sBuf.append("max connection="+oPool.getMaxConn()+"\n");
      Enumeration enumConnections = oPool.getConnections().elements();
      while (enumConnections.hasMoreElements())
      {
       WCDBConnection con = (WCDBConnection) enumConnections.nextElement();
       try
       {
        if (con != null)
        {
         String sState = "free";
         if (con.isFree() == false)
         {
          sState = "running";
          sBuf.append("dsn="+sDsn+",id="+con.m_nID+",state="+sState+",running sql="+con.getSql()+"\n");
         }
         else
         {
          sBuf.append("dsn="+sDsn+",id="+con.m_nID+",state="+sState+",last run sql="+con.getSql()+"\n");
         }
        }
       }
       catch (Exception ex)
       {
        WCLog.getInstance().printLog("exception at WCDBConnectionManager.getConnectionState1 "+ex.toString());
       }
      }
      sBuf.append("\n");
     }
    }
    return sBuf.toString();
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.getConnectionState2 "+ex.toString());
   }
   return null;
  }
  public Vector getConnectionState()
  {
   try
   {
    Vector vRet = new Vector();
    Hashtable htPools = getPools();
    if (htPools == null)
    {
     WCLog.getInstance().printLog("at WCDBConnectionManager.getConnectionState1 htPools is null");
     return null;
    }
    Enumeration enumPools = htPools.elements();
    if (enumPools == null)
    {
     WCLog.getInstance().printLog("at WCDBConnectionManager.getConnectionState1 enumPools is null");
     return null;
    }
    while (enumPools.hasMoreElements())
    {
     WCDBConnectionPool oPool = (WCDBConnectionPool) enumPools.nextElement();
     if (oPool != null)
     {
      WCProperties rRcd = new WCProperties();
      String sDriverName = oPool.getDriverName();
      String sUrl = oPool.getUrl();
      String sUser = oPool.getUser();
      String sPassword = oPool.getPassword();
      String sDsn = oPool.getName();
      rRcd.setValue("dsn",sDsn);
      rRcd.setValue("url",sUrl);
      rRcd.setValue("drivers",sDriverName);
      rRcd.setValue("connectionCount",oPool.getConnectionCount());
      rRcd.setValue("freeConnectionCount",oPool.getFreeConnectionCount());
      rRcd.setValue("maxConnectionCount",oPool.getMaxConn());
      Vector vConnections = new Vector();
      Enumeration enumConnections = oPool.getConnections().elements();
      while (enumConnections.hasMoreElements())
      {
       WCDBConnection con = (WCDBConnection) enumConnections.nextElement();
       try
       {
        if (con != null)
        {
         String sState = "free";
         if (con.isFree() == false)
         {
          sState = "running";
         }
         WCProperties rConn = new WCProperties();
         rConn.setValue("id",con.m_nID);
         rConn.setValue("state",sState);
         rConn.setValue("sql",con.getSql());
         vConnections.addElement(rConn);
        }
       }
       catch (Exception ex)
       {
        WCLog.getInstance().printLog("exception at WCDBConnectionManager.getConnectionState1 "+ex.toString());
       }
      }
      rRcd.setValue("connections",vConnections);
      vRet.addElement(rRcd);
     }
    }
    return vRet;
   }
   catch (Exception ex)
   {
    WCLog.getInstance().printLog("exception at WCDBConnectionManager.getConnectionState2 "+ex.toString());
   }
   return null;
  }
  public static String getDatabaseType(String sDsn)
  {
   String sRet = "";
   WCDBConnectionManager dbConnMngr = WCDBConnectionManager.getInstance();
   WCDBConnectionPool oPool = dbConnMngr.getConnectionPool(sDsn);
   if (oPool != null)
   {
    sRet = oPool.getDatabaseType();
   }
   return sRet;
  }
}
- 소스코드 WCDBConnectionManager.java 끝

출처 : 고급 웹 UI 개발 라이브러리 Web Development Library 소스공개 : http://www.webdevlib.net