spring Framework를 이용한 Oracle JDBC 액세스의 개선
저자 Dustin Marx

spring Framework를 이용하여 Oracle JDBC 액세스를 개선하는 방법을 알아봅니다.

아티클 관련 다운로드: Oracle Database 10g Oracle JDBC Drivers spring Framework

spring Framework는 Apache 라이센스를 통해 공개된 Java/J2EE 애플리케이션 프레임워크로 J2EE 애플리케이션의 다양한 계층을 지원하고 있습니다. spring Framework의 중요한 장점의 하나로 JDBC 데이터 액세스에 관련하여 뛰어난 유지보수성과 안정성을 지원한다는 점을 들 수 있습니다. 이 문서에서는 spring Framework와 Oracle TopLink 오브젝트/관계형(O/R) 매핑 툴을 이용하여 JDBC 코드를 작성하는데 수반되는 반복적 요소와 리스크를 줄이는 방법을 설명합니다. 개발자는 spring Framework를 이용하여 오라클 데이터베이스 기반 환경에서 보다 깔끔하고, 유연하고, 에러 가능성이 적은 JDBC 코드를 작성할 수 있습니다.

Listing 1

try
{
  // JDBC Connection/Statement/Result Set
}
catch (SQLException sqlEx)
{
  // Handle the exception
}
finally
{
  try
  { // Closing connection *should* close statement and result set
   if (stmt != null) stmt.close();
   if (conn != null) conn.close();
  }
  catch (SQLException sqlEx)
  {
   System.err.println("SQLException NOT handled");
  }
}

Listing 2

List commissions = new ArrayList();
Statement stmt = null;
ResultSet rs = null;
try
{
  stmt = this.myConnection.createStatement();
  rs = stmt.executeQuery("SELECT comm FROM emp"); 
  while ( rs.next() )
  {
   Integer commission = new Integer( rs.getInt("COMM") );
   if ( rs.wasNull() )
   {
     // By assigning the commission to null, this effectively
     // represents a null in the database as a Java null.
     System.out.println( "\tCommission seen as " + commission +
               " is really null");
     commission = null;
   }
   commissions.add( commission );
  }
}
catch (SQLException sqlEx)  // checked
{
  System.err.println( "Message: " + sqlEx.getMessage() );
  System.err.println( "Error Code: " + sqlEx.getErrorCode() );
  System.err.println( "SQL State: " + sqlEx.getSQLState() );
}
finally
{
  try
  {
   if ( rs != null ) { rs.close(); }
   if ( stmt != null ) { stmt.close(); }
  }
  catch (SQLException sqlEx) // checked
  {
   System.err.println( sqlEx.getMessage() );
  }
}

Listing 3

List commissions = new ArrayList();
try
{
  JdbcTemplate jt = new JdbcTemplate(this.myDataSource);
  List commList = jt.queryForList( "SELECT comm FROM emp");
  
  Iterator commIter = commList.iterator();
  while ( commIter.hasNext() )
  {
   Number comm = (Number) ((Map) commIter.next()).get("COMM");
   if (comm != null)
     commissions.add( new Integer(comm.intValue()) );
   else commissions.add( null );  } 
}
catch ( DataAccessException ex )  // unchecked exception
{
  System.err.println( ex.getMessage() );
}

다시 Listing 1으로 돌아가 봅시다. 예제 코드에서 명시적으로 처리되는 exception은 java.sql.SQLException이 유일함을 확인할 수 있습니다. SQLException은 데이터베이스 및 SQL에 관련한 다양한 예외 상황을 처리하기 위한 exception입니다. Javadoc은 SQLException 인스턴스로부터 가져올 수 있는 기본적인 정보에 대해 설명하고 있습니다. 이 정보에는 에러의 내용을 기술하는 문자열[getMessage()], 표준화된 SQLState exception String [getSQLState()], 벤더별 정수 에러 코드 [getErrorCode()]등이 포함됩니다. 이 세 가지 정보는 Listing 1에서 모두 사용되고 있습니다.

오라클 데이터베이스에 액세스하는 JDBC 드라이버 관련 에러의 대표적인 예가 표 1에 정리되어 있습니다. "Example Code and/or Comment" 컬럼은 에러의 원인이 되는 SQL 구문의 예와 추가적인 설명을 포함하고 있습니다.

본 문서의 마지막 부분의 “온라인 리소스” 섹션에는 사용자가 마주칠 수 있는 다양한 오라클 데이터베이스 exception에 대한 상세한 정보를 제공하는 웹 사이트 링크가 소개되어 있습니다. Oracle JDBC 드라이버 에러 코드는 Oracle JDBC Developer's Guide and Reference의 Appendix B 에서 참고하실 수 있으며 Oracle Database Error Messages 문서는 오라클 데이터베이스 에러 코드에 대한 일반적인 정보를 담고 있습니다.

Listing 4

<bean id="Oracle”
   class="org.springframework.jdbc.support.SQLErrorCodes">
 <property name="badSqlGrammarCodes">
  <value>900,903,904,917,936,942,17006</value>
 </property>
 <property name="invalidResultSetAccessCodes">
  <value>17003</value>
 </property>
 <property name="dataAccessResourceFailureCodes">
  <value>17002</value>
 </property>
 <property name="dataIntegrityViolationCodes">
  <value>1,1400,1722,2291</value>
 </property>
 <property name="cannotAcquireLockCodes">
  <value>54</value>
 </property>
</bean>

BadSqlGrammarException은 spring이 JDBC 환경을 위해 지원하는 유용한 exception 클래스의 하나입니다. 이 exception 클래스가 제공하는 getSql() 메소드는 exception이 발생한 시점에 호출된 SQL 구문을 반환합니다. 이 클래스가 (일반적인 DAO 클래스와 달리) SQL 구문에 관련한 상세 정보를 갖고 있기 때문에 getSQLException() 메소드를 통한 표준 SQLException 으로의 핸들로써 이용될 수도 있습니다.

Listing 3의 spring 코드 예제는 실행된 SQL의 Statement에 대한 spring의 래핑(wrapping) 기능에 의존하고 있습니다. 하지만, 데이터베이스에 대해 SQL을 실행하는 과정에서 Statement 대신 PreparedStatement가 사용될 수도 있습니다. spring JdbcTemplate 클래스는 Statement와 PreparedStatement를 모두 지원하는 다양한 메소드를 제공하고 있으며, 사용자는 자신이 사용하고자 하는 JDBC 구문의 유형을 선택할 수 있습니다.

Listing 5

String updateStr =
  "UPDATE salgrade SET losal = ?, hisal = ? WHERE grade = ?";
PreparedStatement stmt = null;
   
try
{
  stmt = this.myConnection.prepareStatement(updateStr);
  stmt.setInt(1,aLowSal);
  stmt.setInt(2,aHighSal);
  stmt.setInt(3,aSalGrade);
     
  updateStatus = stmt.execute();
  stmt.close();
} // lots of catch and finally code typically follows here

String updateStr =
  "UPDATE salgrade SET losal = ?, hisal = ? WHERE grade = ?";

JdbcTemplate jt = new JdbcTemplate(this.myDataSource);
jt.update( updateStr,
      new Object[] { new Integer(aLowSal),
             new Integer(aHighSal),
             new Integer(aSalGrade) } );
// No handling/closing of PreparedStatement or catch/finally needed

Listing 7

String queryStr = "SELECT rowid FROM emp WHERE empno = "
         + aEmpNum;  // aEmpNum set previously
String rowId = null;
try
{
  stmt = this.myConnection.createStatement();
  rs = stmt.executeQuery(queryStr);
  while ( rs.next() )
  {
   rowId = rs.getString("ROWID");
  }
} // lots of catch-finally code needed after this

String queryStr = "SELECT rowid FROM emp WHERE empno = "
         + aEmpNum;
String rowId = null;
  
try
{
  JdbcTemplate jt = new JdbcTemplate(this.myDataSource);
  oracle.sql.ROWID oraRowId =
   (ROWID) jt.queryForObject(queryStr, ROWID.class);
  rowId = oraRowId.stringValue();
}
catch ( IncorrectResultSizeDataAccessException wrongSizeEx )
{
  // This unchecked exception is thrown in this case if more
  // than one result is returned from the query.
  // Explicitly printing out the results of this exception's
  // methods getExpectedSize() and getActualSize() is really not
  // necessary in this case because this exception's getMessage()
  // returns this same information in sentence form. 
  System.err.println( wrongSizeEx.getMessage() );
  System.err.print( "Expected " + wrongSizeEx.getExpectedSize()
          + " results, but actually got back "
          + wrongSizeEx.getActualSize() + " results.");
}

Listing 9

String queryStr = "SELECT sysdate FROM dual";
Date date = null;
  
try
{
  JdbcTemplate jt = new JdbcTemplate(this.myDataSource);
  date = (Date) jt.queryForObject(queryStr, Date.class);
}
catch ( BadSqlGrammarException badSqlEx ) // unchecked
{
  System.err.println( badSqlEx.getMessage() );
  System.err.println( "Bad SQL: " + badSqlEx.getSql() );
}

Listing 10

Statement stmt = null;

try
{
  stmt = this.myConnection.createStatement();
  stmt.executeUpdate("DROP TABLE salgrade PURGE");
}
catch ( SQLException sqlEx )
{
  System.err.println("Message: " + sqlEx.getMessage());
  System.err.println("Error Code: " + sqlEx.getErrorCode());
  System.err.println("SQL State: " + sqlEx.getSQLState());
}
finally
{
  try
  {
   if (stmt != null)
   {
     stmt.close();
   }
  }
  catch (SQLException finallySqlEx)  // checked exception
  {
   System.err.println(finallySqlEx.getMessage());
  }
}

try
{
  JdbcTemplate jt = new JdbcTemplate(this.myDataSource);
  jt.execute("DROP TABLE salgrade PURGE");
}
catch ( BadSqlGrammarException badSqlEx ) // unchecked
{
  System.err.println( badSqlEx.getMessage() );
  System.err.println( "BadSQL: " + badSqlEx.getSql() );
}

Listing 12

CREATE OR REPLACE PROCEDURE salary_percentile (
  salary IN emp.sal%TYPE,
  low IN salgrade.losal%TYPE,
  high IN salgrade.hisal%TYPE,
  percentile OUT NUMBER )
AS
BEGIN
 IF salary < 0 THEN
  percentile := null;
 ELSE
  percentile := (salary - low) / (high - low);
 END IF;
END;

String escapeString = "{call salary_percentile (?,?,?,?)}";
CallableStatement cStmt = null;
double percentile = -1.0;
final int PERCENTILE_INDEX = 4;
   
try
{
  cStmt = this.myConnection.prepareCall(escapeString);
  cStmt.setInt(1, aSalary); // aSalary passed into this method
  cStmt.setInt(2, aLow);   // aLow passed into this method
  cStmt.setInt(3, aHigh);  // aHigh passed into this method
  cStmt.registerOutParameter(PERCENTILE_INDEX, Types.DOUBLE);
  cStmt.execute();
  percentile = cStmt.getDouble(PERCENTILE_INDEX);
}
catch ( SQLException sqlEx )
{
  System.err.println("Message: " + sqlEx.getMessage());
  System.err.println("Error Code: " + sqlEx.getErrorCode());
  System.err.println("SQL State: " + sqlEx.getSQLState());
}
finally
{
  if ( cStmt != null )
  {
   try
   {
     cStmt.close();
   }
   catch (SQLException finallySqlEx)
   {
     System.err.println(finallySqlEx.getMessage());
   }
  }
}

return percentile;

Listing 14

private class SalaryCalculator extends StoredProcedure
{
  /** Name of procedure in database. */
  public static final String PROC_NAME = "salary_percentile";

  /**
  * Constructor for this StoredProcedure class.
  * @param ds Data Source.
  */
  public SalaryCalculator(DataSource ds)
  {
   setDataSource(ds);
   setSql(PROC_NAME);

   // Parameters should be declared in same order here that
   // they are declared in the stored procedure. 

   declareParameter(new SqlParameter("salary", Types.DOUBLE));
   declareParameter(new SqlParameter("low", Types.INTEGER));
   declareParameter(new SqlParameter("high", Types.INTEGER));
   declareParameter(new SqlOutParameter( "percentile",
                      Types.DOUBLE ) );
   compile();
  }
   
  /**
  * Execute stored procedure.
  * @return Results of running stored procedure.
  */
  public Map executeCalculation( double aSalary,
                 int aLow,
                 int aHigh )
  {
   Map inParameters = new HashMap();
   inParameters.put( "salary", new Double(aSalary) );
   inParameters.put( "low", new Integer(aLow) );
   inParameters.put( "high", new Integer(aHigh) );
   Map out = execute( inParameters ); // Call on parent class
   return out;
   }
  }

// . . .
// Code below is all that is needed to call your Stored Procedure
// created above. 
// . . .

  SalaryCalculator calcPercentile =
   new SalaryCalculator(this.myDataSource);
  Map calcResults =
   calcPercentile.executeCalculation(aSalary, aLow, aHigh);
   
  return ((Double)calcResults.get("percentile")).doubleValue();

// . . .
// remainder of class
// . . .

0보다 작은 salary가 스토어드 프로시저에 전달되는 경우, Listings 13과14 에서 각각 다르게 처리된다는 점을 참고하시기 바랍니다. 일반적인 JDBC 코드(Listing 13)의 경우, 0.0의 값이 반환되며, 결과가 null인지 확인하기 위해서는 wasNull()을 사용해야만 합니다. spring 기반 코드(Listing 14)에서는, Java null이 반환되며 wasNull()의 호출이 불필요합니다.

Listing 15

CREATE OR REPLACE TYPE address_type AS OBJECT
(
 STREET VARCHAR2(20),
 CITY  VARCHAR2(15),
 STATE  CHAR(2),
 ZIP   CHAR(5)
);
/

CREATE TABLE emp_address_table
(
 EMP_NUM NUMBER(4),
 ADDRESS ADDRESS_TYPE
);

Listing 16

String queryStr =  "SELECT address FROM emp_address_table WHERE "
         + "emp_num = " + aEmpNum; // aEmpNum passed in
final List addresses = new ArrayList();
  
JdbcTemplate jt = new JdbcTemplate(this.myDataSource);
jt.query( queryStr,
     new RowCallbackHandler()
     {
       public void processRow(ResultSet rs)
        throws SQLException
       {
        // The Struct and ResultSet methods throw
        // SQLException, so throws above is necessary
        java.sql.Struct address =
         (java.sql.Struct) rs.getObject(1);
        String street =
          address.getAttributes()[0].toString();
        String city =
          address.getAttributes()[1].toString();
        String state =
          address.getAttributes()[2].toString();
        String zipCode =
          address.getAttributes()[3].toString();
        String addressStr = street + ", " + city + ", "
                  + state + " " + zipCode;
        addresses.add( addressStr );
       }
     }
    );

String updateStr =  "UPDATE emp_address_table SET address = ? "
          + "WHERE emp_num = ?";

JdbcTemplate jt = new JdbcTemplate( getDataSource() );
jt.update( updateStr,
      new PreparedStatementSetter()
      {
       public void setValues(PreparedStatement ps)
         throws SQLException
       {
         Address address = new Address();
         address.setStreet(aStreet);
         address.setCity(aCity);
         address.setState(aState);
         address.setZip(aZipCode);
          
         ps.setObject(1, address);
         ps.setInt(2, aEmpNum);
       }
      }
);

• spring의 JdbcTemplate 클래스는 위에서 설명된 것과 유사한 여러 가지 spring 기반 인터페이스를 제공합니다. 한 예로, ResultSetExtractor와 PreparedStatementCreator는 RowCallbackHandler 및 PreparedStatementSetter와 유사한 기능을 제공합니다. JdbcTemplate이 지원하는 유용한 인터페이스의 또 다른 예로 BatchPreparedStatementSetter를 들 수 있습니다.
• spring 애플리케이션 컨텍스트에서 spring의 JDBC 추상화 기능을 반드시 사용해야 하는 것은 아니지만, 그 적용효과는 분명합니다. 개발자는 코드에 직접 커플링하는 대신, spring Framework의 설정 파일을 이용하여 비즈니스 오브젝트를 데이터 액세스 오브젝트와 매핑할 수 있습니다.
• org.springframework.jdbc.object 패키지는 재활용 가능한 오브젝트의 형태로 (DML 작업 및 스토어드 프로시저를 포함하는) 관계형 데이터베이스 작업을 지원합니다. 개발자는 쓰레드 조작의 안정성을 보장해주는 “threadsafe” 오브젝트를 이용하여 보다 높은 수준의 관계형 데이터베이스 추상화 환경을 구현할 수 있습니다. 필자는 개인적으로 JdbcTemplate이 제공하는 추상화 수준에 매우 만족하고 있으며, exception, 결과 셋, 리소스 관리 등의 측면에서 개발자가 원하는 수준의 처리 기능이 제공되고 있다고 평가합니다. 하지만, (TopLink, Hibernate와 같은) O/R(object-relational) 매핑 테크놀로지를 사용하지 않으면서 한층 더 높은 수준의 관계형 데이터베이스 개념의 추상화를 구현하고자 하는 경우라면, org.springframework.jdbc.object 패키지를 고려해 볼 것을 추천합니다 Listing 12의 스토어드 프로시저 예제에 이 패키지의 활용 방법이 간략하게 예시되고 있습니다.
• spring Framework는 컨테이너 외부에서 사용될 수 있는 단순한 형태의 DataSource를 제공하며, 필요 시 override가 가능한 추상화된 datasource 클래스를 지원합니다 (spring Reference Documentation의 Chapter 10 참고).
• spring Framework는 JDBC 이외에도 Hibernate, iBatis, Java Data Objects (JDO)와 같은 O/R 매핑 테크놀로지를 지원합니다. (spring Reference Documentation의 Chapter 11 참고). 본 문서의 “온라인 리소스” 글상자에서 spring과 Oracle TopLink를 함께 활용하는 방법을 소개한 문서의 링크를 참조하실 수 있습니다.
• spring Framework는 테크놀로지 독립적(technology-agnostic)한 DAO 인터페이스와 공통 exception hierarchy를 공유하는 개발 환경을 지원합니다. spring Reference Documentation의 Chapter 9 참고). 이 주제는 본 문서의 여러 부분에서 언급되고 있습니다.
• spring Framework는 SQLWarnings을 exception(SQLWarningException)의 형태로 캡처하는 기능을 지원합니다. 이 기능은 거의 모든 상황에서 SQLException을 발생시키는 오라클 데이터베이스, JDBC 드라이버 기반 환경에서는 그리 유용하지 않습니다. 이 기능은 개발자가 경고(warning) 내용에 대해 보다 깊이 이해하고자 하는 경우, 또는 SQLWarning을 빈번하게 발생시키는 데이터베이스를 사용하는 경우에 주로 사용됩니다. 이 경우, JDBC만을 사용하는 개발자는 SQLWarning이 발생했는지 확인하는 코드를 일일이 작성해야 합니다. spring Framework는 보다 쉽고 일관성 있는 경고 처리를 가능하게 합니다.
• spring Framework는 org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor 인터페이스와 이 인터페이스의 몇 가지 implementation(예: SimpleNativeJdbcExtractor)을 지원합니다. 이 인터페이스는 데이터베이스 연결이 다른DataSource를 통해 래핑(wrapping)되어 있거나, 연결 풀(connection pool)이 사용되는 환경에서 오라클 연결 또는 ResultSet을 통해 오라클의 기능에 접근하기 위한 방법으로 유용하게 활용됩니다.
• spring Framework는 oracle.sql.BLOB(binary large object)과 oracle.sql.CLOB(character large object)의 인스턴스 생성을 위한 클래스로 org.springframework.jdbc.support.lob.OracleLobHandler를 제공합니다r.
• spring Framework의 OracleSequenceMaxValueIncrementer 클래스는 Oracle sequence의 다음 값을 확인하는 용도로 사용됩니다. 이 클래스는 “select someSequence.nextval from dual” (someSequence는 오라클 데이터베이스의 sequence 이름)을 커맨드 상에서 실행한 것과 동일한 결과를 제공합니다. 이 클래스를 사용하는 경우, 오라클 환경에 긴밀하게 커플링(thigh coupling)되지 않은 환경에서 DataFieldMaxValueIncrementer를 DAO hierarchy 내에서 활용할 수 있다는 이점이 있습니다.

출처 : Tong - 반이오타님의 JAVA Framework통