다음은 INSERT 예제이다.

public void insertQuery() throws Exception{
    IQueryService queryService = (IQueryService) context.getBean("queryService");
    //create() : XML mapping파일에 정의되어 있는 SQL query를 이용하여 INSERT를 실행한다.
    int rs = queryService.create
            ("create", new Object[] { "1234567890123", "AAAAA" , "seoul"});
    if ( rs == -1 ){
        throw new Exception("Insert query failed");
    }
}

다음은 SELECT 예제이다.

public void selectQuery() throws Exception{
    IQueryService queryService = (IQueryService) context.getBean("queryService");
    //find() : XML mapping파일에 정의되어 있는 SQL query를 이용하여 SELECT를 실행한다.

    //일반적인 경우(table과 class를 mapping하지 않은 경우)
    ArrayList rsquery  = (ArrayList) queryService
            .find("selectGeneral", new Object[] { "%12345%" });
    Map hsRsquery = new HashMap();
    for( int i = 0 ; i < rsquery.size() ; i ++ ){
        hsRsquery = (Map) rsquery.get(i);
        String name = (String) hsRsquery.get("name");
    }
    
    /*매핑 XML에 해당 클래스와 매핑되는 테이블이 존재하지 않을 경우,
    * 쿼리 수행 결과에 대해 하나의 Row별로 칼럼명,
    * 해당값을 쌍으로 org.apache.commons.collections.map.ListOrderedMap에 put하고 
    * ListOrderedMap들을 ArrayList에 담은 형태로 결과값을 리턴하게 된다.
    */

    //Table - Class mapping을 사용한 경우
    Collection rsqueryNotUsingResultMapping = queryService
            .find("selectNotUsingResultMapping", new Object[] { "%12345%" });
    Iterator rsqueryItr = rsqueryNotUsingResultMapping.iterator();
    while (rsqueryItr.hasNext()) {
        Customer customer = (Customer) rsqueryItr.next();
        String name =  customer.getNm();
    }

    //result-mapping을 사용한 경우
    Collection rsqueryUsingResultMapping = queryService
            .find("selectUsingResultMapping", new Object[] { "%12345%" });
    Iterator rsqueryItr_01 = rsqueryUsingResultMapping.iterator();
    while (rsqueryItr_01.hasNext()) {
        CompositionCustomer compositionCustomer 
                = (CompositionCustomer) rsqueryItr_01.next();
        String name =  compositionCustomer.getCompositionName();
    }

    System.out.println("rsquery.size() : " 
            + rsquery.size());
    System.out.println("rsqueryNotUsingResultMapping.size() : " 
            + rsqueryNotUsingResultMapping.size());
    System.out.println("rsqueryUsingResultMapping.size( : " 
            + rsqueryUsingResultMapping.size();
}

다음은 UPDATE 예제이다.

public void updateQuery() throws Exception {
    IQueryService queryService = (IQueryService) context
            .getBean("queryService");
    //update() : XML mapping파일에 정의되어 있는 SQL query를 이용하여 UPDATE를 실행한다.
    int rs = queryService.update("update"
            , new Object[] { "9999999999999", "AAAAA" , "busan" , "1234567890123"});
    if ( rs == -1 ){
        throw new Exception("Update query failed");
    }
}

다음은 DELETE 예제이다.

public void deleteQuery() throws Exception {
    IQueryService queryService = (IQueryService) context
            .getBean("queryService");
    //remove() : XML mapping파일에 정의되어 있는 SQL query를 이용하여 DELETE를  실행한다.
    int rs = queryService.remove("delete", new Object[] { "9999999999999" });
    if ( rs == -1 ){
        throw new Exception("Delete query failed");
    }
}

조회 결과 매핑을 위해 <table-mapping/>, <result-mapping/>을 별도로 정의하지 않은 경우, 쿼리문 수행 결과는 각 결과 Row 별로 Map에 담아 ArrayList 형태로 리턴된다. 조회 결과값을 추출하기 위해서는 각 Map으로부터 get("칼럼명")을 통해 해당 칼럼의 값을 얻어낼 수 있다.

<queryservice>
    <queries>
       <query id="selectGeneral" isDynamic="false">
          <statement>
             SELECT * FROM TBL_CUSTOMER WHERE SSNO like ?
          </statement>
          <param type="VARCHAR" />
       </query>
    </queries>
</queryservice>

특정 클래스와 단일 테이블 사이의 매핑 정보를 정의할 때 사용하며, 테이블과 특정 클래스 간의 매핑 정보를 정의해 두면 특정 조회문의 조회 결과를 매핑할 때 별도의 <result-mapping>없이 해당 클래스명만 <result>에 정의해 두면 되므로 XML 정의가 보다 간단해질 수 있다. 또한 <table-mapping>을 이용하면 별도 쿼리문 정의없이 객체만으로도 단건 데이터 생성/수정/삭제/조회가 가능해진다. <result class=""anyframe.sample.domain.Customer"/>와 같이 table mapping시 정의한 클래스를 이용하면 쿼리문 수행 결과는 해당 클래스의 setter 호출을 통해 저장되고, getter를 호출함으로써 결과값을 얻을 수 있게 된다.

<queryservice>
    <table-mapping>
        <table name="TBL_CUSTOMER"
            class="anyframe.sample.domain.Customer">
            <field-mapping>
                <dbms-column>ssno</dbms-column>
                <class-attribute>ssno</class-attribute>
            </field-mapping>
            <field-mapping>
                <dbms-column>name</dbms-column>
                <class-attribute>nm</class-attribute>
            </field-mapping>
            <field-mapping>
                <dbms-column>address</dbms-column>
                <class-attribute>addr</class-attribute>
            </field-mapping>
            <primary-key>
                <dbms-column>ssno</dbms-column>
            </primary-key>
        </table>
    </table-mapping>    
    <queries>
       <query id="select" isDynamic="false">
          <statement>
             SELECT * FROM TBL_CUSTOMER WHERE SSNO like ?
          </statement>
          <param type="VARCHAR" />
          <result class="anyframe.sample.domain.Customer"/>
       </query>
    </queries>
</queryservice>	

매핑 대상 클래스의 속성명이 조회 칼럼명과 동일하거나 CamelCase된 형태이어서, <table-mapping>나 <result-mapping>를 통해 별도 매핑을 수행하지 않아도 되는 경우에 사용할 수 있다. 즉, isCamelCase, mappingStyle 속성값에 따라 조회된 칼럼명과 매핑되는 클래스의 속성명을 찾는다. (예를 들어, mappingStyle의 속성값이 'camel'이고 조회 칼럼명이 USER_NAME인 경우 매핑되는 속성명은 userName이 된다.))

<queryservice>
    <queries>
        <query id="getUser" isDynamic="false">
            <statement>
                SELECT USER_ID, USER_NAME, PASSWORD, SSN, SL_YN, 
                    BIRTH_DAY, AGE, CELL_PHONE, ADDR, EMAIL, EMAIL_YN, 
                    IMAGE_FILE, REG_DATE
                FROM USERS
                WHERE USER_ID = ?
            </statement>
            <param type="VARCHAR" />
            <result class="anyframe.sample.domain.User"/>
        </query>
    </queries>
</queryservice>

* Query 서비스는 내부적으로 쿼리문 수행으로 얻어진 조회 결과를 매핑할 때 다음과 같은 순서로 매핑 기준을 찾는다.

<result-mapping>은 <table-mapping>에 정의되지 않은 클래스이면서, 조회된 칼럼명과 매핑 클래스의 속성명이 연관성이 없어 별도 매핑이 필요한 경우 사용한다. <result-mapping>에 해당 column과 attribute를 일대일로 매핑한다. <result>에 정의된 클래스의 setter 호출을 통해 저장되고, getter 호출을 통해 결과값을 얻을 수 있다.

<queryservice>
    <queries>
        <query id="selectUsingResultMapping" isDynamic="false">
            <statement>SELECT * FROM TBL_CUSTOMER WHERE SSNO like ?</statement>
            <param type="VARCHAR"/>
            <result class="anyframe.sample.domain.CompositionCustomer">
                <result-mapping column="NAME" attribute="nm"/>
                <result-mapping column="ADDRESS" attribute="addr"/>
            </result>
        </query>
    </queries>
</queryservice>

다음은 앞서 제시한 매핑 XML 파일에 정의된 쿼리문을 실행하는 테스트 코드의 일부이다.

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 조회하는 테스트 코드
 */
public void selectCustomer() throws Exception{
    QueryService queryService = (QueryService) context.getBean("queryService");

    //find() : 매핑 XML 파일에 정의되어 있는 query id를 이용하여 SELECT를 실행한다.

    //별도 Result Mapping을 정의하지 않은 경우
    ArrayList rsquery  = (ArrayList) queryService
                                 .find("selectGeneral", new Object[] { "%12345%" });
    Map hsRsquery = new HashMap();
    for( int i = 0 ; i < rsquery.size() ; i ++ ){
        hsRsquery = (Map) rsquery.get(i);
        String name = (String) hsRsquery.get("name");
    }
	
    // table-mapping을 정의한 경우
    Collection rsqueryUsingTableMapping = queryService.find(
            "selectUsingTableMapping", new Object[] { "%12345%" });
    Iterator rsqueryItr = rsqueryUsingTableMapping.iterator();
    while (rsqueryItr.hasNext()) {
        Customer customer = (Customer) rsqueryItr.next();
        String name = customer.getNm();
    }

    // result-mapping을 정의한 경우
    Collection rsqueryUsingResultMapping = queryService.find("selectUsingResultMapping"
            , new Object[] { "%12345%" });
    Iterator rsqueryItr_01 = rsqueryUsingResultMapping.iterator();
    while (rsqueryItr_01.hasNext()) {
        CompositionCustomer compositionCustomer 
                = (CompositionCustomer) rsqueryItr_01.next();
        String name =  compositionCustomer.getCompositionName();
    }
	
    // result class만 정의한 경우
    Collection rsqueryUsingOnlyResultClass = queryService.find(
            "selectUsingOnlyResultClass", new Object[] { "%12345%" });
    Iterator rsqueryItr_02 = rsqueryUsingOnlyResultClass.iterator();
    while (rsqueryItr_02.hasNext()) {
        CamelCasedCustomer camelCasedCustomer
                (CamelCasedCustomer) rsqueryItr_02.next();
        String name = camelCasedCustomer.getName();
    }	
}

다음은 Query 서비스를 정의한 context-query.xml 파일의 일부이다.

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean> 

다음은 매핑 XML 파일에 별도 쿼리문을 정의하지 않고 쿼리문을 직접 입력하여 실행하는 테스트 코드의 일부이다. 다음에서 볼 수 있듯이 Query 서비스는 매핑 XML 파일없이도 INSERT, SELECT, UPDATE, DELETE를 실행할 수 있도록 지원한다.

/**
 * 테스트 코드를 샐행하기 위한 data table 생성
 */
public void insertCustomer() throws Exception{
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    //createBySQL() : 매핑 XML 파일에 쿼리문이 정의되어 있지 않을 때 INSERT를 실행한다.
    int result = queryService.createBySQL(
            "insert into TBL_CUSTOMER values (?, ?, ?)",
            new String[] {"VARCHAR", "VARCHAR", "VARCHAR" },
            new Object[] {"1234567890123", "GilDongHong", "Seoul" });
    if ( result == -1 ){
        throw new Exception("Insert Query failed");
    }
}

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 조회하는 테스트 코드
 */	
public void selectCustomer() throws Exception{
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    //findBySQL() :  매핑 XML 파일에 쿼리문이 정의되어 있지 않을 때 SELECT를 실행한다.
    Collection result = queryService.findBySQL(
            "select NAME, ADDRESS from TBL_CUSTOMER where SSNO like ?",
            new String[] { "VARCHAR" }, 
            new Object[] { "%4567890123" });
    Iterator resultItr = result.iterator();
    while( resultItr.hasNext() ){
        Map resultMap = (Map) resultItr.next();
        resultMap.get("name");
    }
	
    System.out.println("result.size() : " + result.size());
}

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 수정하는 테스트 코드
 */	
public void updateCustomer() throws Exception{
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    //updateBySQL() : 매핑 XML 파일에 쿼리문이 정의되어 있지 않을 때 UPDATE를 실행한다.
    int result = queryService.updateBySQL(
            "update TBL_CUSTOMER set NAME=? where SSNO=?", 
            new String[] {"VARCHAR", "VARCHAR" }, 
            new Object[] { "Anonymous","1234567890123" });
			
    System.out.println("result : " + result);
}

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 삭제하는 테스트 코드
 */
public void deleteCustomer() throws Exception{
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    //removeBySQL() : 매핑 XML 파일에 쿼리문이 정의되어 있지 않을 때 DELETE를 실행한다.
    int result = queryService.removeBySQL(
            "delete from TBL_CUSTOMER where SSNO=?", 
            new String[] { "VARCHAR" },
            new Object[] { "1234567890123" });
			
    System.out.println("result : " + result);
}

다음은 Query 서비스를 정의한 context-query.xml과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml 파일의 일부이다.

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
		<property name="mappingFiles">
			<value>
			    <!-- xml files in folder -->
			    file:./src/test/resources/foldermappings/**/testcase-*.xml,
				file:./src/test/resources/dynamicreload/testcase-queries-dynamicreload.xml,
				<!-- xml files in classpath -->
  		    	classpath*:/mappings/testcase-queries-dynamic.xml,
  		    	classpath*:/mappings/testcase-queries-general.xml,
  		   		classpath*:/mappings/testcase-queries-resultmapping.xml,
  		    	classpath*:/mappings/testcase-queries-resultsetmapper.xml,
  		    	classpath*:/mappings/testcase-table-mappings.xml,
  		    	classpath*:/mappings/testcase-queries-extended.xml,
  		    	classpath*:/mappings/testcase-queries-mappingstyle.xml,
  		   		<!-- xml files in jar  --> 
  		    	classpath*:/jarmappings/testcase-queries-lob.xml
			</value>
		</property>	
		중략 ...
	</bean>

다음은 앞서 정의한 Query 서비스를 통해 로드된 mapping-query-ormapping.xml 파일의 일부로, 테이블 TBL_ORMapping와 ORMapping 클래스 사이의 매핑 정보를 포함하고 있다.

<queryservice>
    <table-mapping>
        <table name="TBL_ORMapping"
            class="anyframe.sample.domain.ORMapping">
            <field-mapping>
                <dbms-column>id</dbms-column>
                <class-attribute>id</class-attribute>
            </field-mapping>
            <field-mapping>
                <dbms-column>name</dbms-column>
                <class-attribute>nm</class-attribute>
            </field-mapping>
            <field-mapping>
                <dbms-column>address</dbms-column>
                <class-attribute>addr</class-attribute>
            </field-mapping>
            <primary-key>
                <dbms-column>id</dbms-column>
            </primary-key>
        </table>
    </table-mapping>
</queryservice>

다음은 앞서 언급한 매핑 XML 파일에 정의된 OR Mapping 정보를 기반으로 특정 테이블에 데이터를 INSERT, UPDATE, SELECT할 때 사용되는 클래스 ORMapping.java 내용의 일부이다.

public class ORMapping implements Serializable {

    public String id;
    public String nm;
    public String addr;
	
    public ORMapping() {
    }
	
    public ORMapping(String i, String n, String a) {
        id = i;
        nm = n;
        addr = a;
    }
	
    // getter, setter ...
}

다음은 매핑 XML 파일에 별도 쿼리문을 정의하지 않고 객체만을 이용하여 INSERT, SELECT, UPDATE, DELETE를 실행하는 테스트 코드의 일부이다. 매핑 클래스에 필요한 값을 셋팅하여 Query 서비스에 전달함으로써 해당하는 쿼리문을 실행시킬 수 있다.

/**
 * Query 서비스를 통해 DB에 신규 데이터를 입력하는 테스트 코드
 */	
public void insertORMapping() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    ORMapping ormapping = new ORMapping("1234567890123", "HonggilDong", "Ansan");

    // ORMapping 객체에 초기값을 셋팅하고 이 객체를 통해 INSERT를 실행한다.
    // 다음 코드에 의해 실행되는 쿼리문은
    // INSERT INTO TBL_ORMapping (address ,name ,id ) 
    // values ( '1234567890123', 'HonggilDong', 'Ansan' )	
    int result = queryService.create(ormapping);
    System.out.println("result : " + result);
}

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 조회하는 테스트 코드
 */	
public void selectORMapping() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    ORMapping ormapping = new ORMapping();
    ormapping.setId("1234567890123");

    // primary-key로 지정한 칼럼에 매핑되는 attribute에 값을 입력하고 
    // find를 실행하면 primary-key를 조회 조건으로  하는 SELECT를 실행한다.
    // 다음 코드에 의해 실행되는 쿼리문은 
    // SELECT NAME, ADDRESS FROM TBL_ORMAPPING WHERE ID = '1234567890123'
    Collection result = queryService.find(ormapping);
    if ( result.size() != 1 ){
        throw new Exception("Select failed");
    }
}

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 수정하는 테스트 코드
 */	
public void updateORMapping() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    ORMapping ormapping = new ORMapping("1234567890123", "HonggilDongn", "Seoul");

    // 다음 코드에 의해 실행되는 쿼리문은 
    // Update TBL_ORMapping set address = 'Seoul' ,name = 'HonggilDong'
       where id = '1234567890123'	
    int result = queryService.update(ormapping);
    if ( result == -1 ){
        throw new Exception("Update failed");
    }
}

/**
 * Query 서비스를 통해 DB에 입력된 데이터를 삭제하는 테스트 코드
 */	
public void deleteORMapping() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
		
    ORMapping ormapping = new ORMapping();
    ormapping.setId("1234567890123");
	
    // 다음 코드에 의해 실행되는 퀴리문은 
    // DELETE FROM TBL_ORMapping where id = 1234567890123	
    int result = queryService.remove(ormapping);
    if ( result == -1 ){
        throw new Exception("Update failed");
    }
}

다음은 Query 서비스를 정의한 context-query.xml 과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml 파일의 일부이다.

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
   	<config:configuration>
        <filename>classpath:/query/mapping-query-dynamic.xml</filename>
        중략...
    </config:configuration>		
</bean>

다음은 앞서 정의한 Query 서비스를 통해 로드된 mapping-query-dynaminc.xml의 일부로, 여러 유형의 dynamic 쿼리문을 포함하고 있다.

<queries>	
    <query id="getLogonIdByNamedParam" isDynamic="true">
        <statement>
            SELECT LOGON_ID 
            FROM TBL_USER 
            WHERE LOGON_ID BETWEEN :lowId AND :highId
        </statement>
        <param name="lowId" type="VARCHAR"/>
        <param name="highId" type="VARCHAR"/>
    </query>
    <query id="getEmployeesByTextReplacement" isDynamic="true">
        <statement>
            SELECT LOGON_ID 
            FROM {{schema}} 
            ORDER BY {{sortColumn}}
        </statement>
    </query>
    <query id="getLogonIdByIf" isDynamic="true">
        <statement>
            SELECT LOGON_ID 
            FROM TBL_USER 
            #if ($id && !$id.equals(""))
            WHERE LOGON_ID like '%' || :logonId || '%'
            #end 
            ORDER BY {{sortColumn}}
        </statement>
        <param name="logonId"	type="VARCHAR"/>
    </query> 
    <query id="getLogonIdByForeach" isDynamic="true">
        <statement>
            SELECT LOGON_ID, NAME 
            FROM TBL_USER 
            WHERE LOGON_ID IN (
                #foreach ($logonId in $logonIdList) 
                    #if ($velocityCount	== 1 ) 
                        '$logonId' 
                    #else 
                        , '$logonId' 
                    #end
                #end 
            ) 
            ORDER BY NAME
        </statement> 
    </query> 	
</queries>

다음은 앞서 언급한 매핑 XML 파일에 정의된 parameter 값에 따라 동적으로 변경 가능한 쿼리문들을 실행하는 테스트 코드의 일부이다.

/**
 * Named Parameter를 이용해서 query id가 'getLogonIdByNamedParam'인 Dynamic 쿼리문을
 * 실행한다. getLogonIdByNamedParam : key가 lowId, highId인 Named Parameter의 값을  
 * key=value 형태로 Query 서비스에 전달하면 Query 서비스는 해당 value를 PreparedStatement
 * 에 셋팅하고 해당 쿼리문을 실행한다. 이 메소드에서는 "lowId = a", "highId = z"라는  
 * paramter를  Object[] 형태로 Query 서비스에 전달하고 있으며, 이 때 실행되는 쿼리문은
 * 다음과 같다.
 * SELECT LOGON_ID FROM TBL_USER WHERE LOGON_ID BETWEEN 'a' AND 'z'
 */
public void dynamicQueryUsingNamedParameter() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    Object[] iVal = new Object[2];
    iVal[0] = new Object[]{"lowId", "a"};
    iVal[1] = new Object[]{"highId", "z"};
	
    ArrayList rtList 
        = (ArrayList)(queryService.find("getLogonIdByNamedParam", iVal));
    System.out.println("rtList.size() : " + rtList.size());
}

/**
 * {{치환문자열키}}를 이용해서  query id가 'getEmployeesByTextReplacement'인 Dynamic 
 * 쿼리문을 실행한다. getEmployeesByTextReplacement : key가 schema, sortColumn인  
 * 치환문자열의 값을 key=value 형태로 Query 서비스에 전달하면 Query 서비스는 해당 value를  
 * 문자열로 그대로 치환해서 사용한다. 이 메소드에서는 "schema=TBL_USER", "sortColumn=NAME"  
 * 라는 parameter를 Object[] 형태로 Query 서비스에 전달하고 있으며, 이 때 실행되는 쿼리문은
 * 다음과 같다.
 * SELECT * FROM TBL_USER ORDER BY NAME
 */
public void dynamicQueryUsingTextreplace() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    Object[] iVal = new Object[2];
    iVal[0] = new Object[]{"schema", "TBL_USER"};
    iVal[1] = new Object[]{"sortColumn", "NAME"};
	
    ArrayList rtList 
        = (ArrayList)(queryService.find("getEmployeesByTextReplacement", iVal));
    System.out.println("rtList.size() : " + rtList.size());
}

/**
 * 조건분기를 위한 #if를 이용해서  query id가 'getLogonIdByIf'인 Dynamic 쿼리문을 실행한다.
 * getLogonIdByIf : key가 id인 parameter의 값이 Null이 아니고, 빈 문자열도 아니라면, #if문  
 * 내에 포함된 WHERE절이 실행될 쿼리문에 포함된다. (#if문이 끝나는 지점에는 반드시 #end를 
 * 정의해주어야 함에 유의하자.)
 * 또한, WHERE절 내에서는  '%' || :logonId || '%'와 같은 형태의 문장을 사용하고 있는데 
 * 이것은 Named Parameter의 값에 앞뒤로 %를 붙인 형태의 문자열을 만들어 내기 위함이다. 
 * (이 때, '%', ||, :logonId 사이에는 빈 칸을 두어야 WHERE절이 정상적으로 동작한다. )
 * 이 메소드에서는 "id=test", "sortColumn=NAME" 라는 parameter를 Object[] 형태로 Query
 * 서비스에 전달하고 있으며 실행되는 쿼리문은 다음과 같다.
 * SELECT LOGON_ID 
 * FROM TBL_USER 
 * WHERE LOGON_ID like '%test%' 
 * ORDER BY NAME
 */
public void dynamicQueryUsingCondition() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    Object[] iVal = new Object[3];
    iVal[0] = new Object[]{"id", "yes"};
    iVal[1] = new Object[]{"logonId", "test"};
    iVal[2] = new Object[]{"sortColumn", "NAME"};
	
    ArrayList rtList 
        = (ArrayList)(queryService.find("getLogonIdByIf", iVal));
    System.out.println("rtList.size() : " + rtList.size());
}

/**
 * Loop를 위한 #foreach를 이용해서  query id가 'getLogonIdByForeach'인 Dynamic 쿼리문을
 * 실행한다. getLogonIdByForeach : key가 logonIdList인  parameter의 값은 List 형태이며, 
 * List에서 순서대로 추출된 값들은 내부적으로 logonId라는 변수에 셋팅된다. logonId는 
 * Query 서비스에 전달되어야 하는 입력 parameter가 아니다.
 * velocityCount가 1인 경우 즉, 첫번째 Loop일 경우 logonIdList의 첫번째 값이 그대로  
 * 추가되고 그 이후부터는 ,를 붙인 값이 추가되게 된다. (#foreach, #if문이 끝나는 지점에는
 * 반드시 #end를 정의해주어야 함에 유의하자.) 이 메소드에서는 logonIdList의 값이 "admin", 
 * "test"라는 두개의 문자열로 구성된 ArrayList를 Object[] 형태로 Query 서비스에 전달하고
 * 있으며 실행되는 쿼리문은 다음과 같다.
 * SELECT LOGON_ID, NAME 
 * FROM TBL_USER 
 * WHERE LOGON_ID IN ('admin', 'test') 
 * ORDER BY NAME
 */
public void dynamicQueryUsingLoop() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");

    List logonIdList = new ArrayList();
    logonIdList.add("admin");
    logonIdList.add("test");

    Object[] iVal = new Object[]{"logonIdList", logonIdList};

    ArrayList rtList 
        = (ArrayList) (queryService.find("getLogonIdByForeach", new Object[]{ iVal })); 

    if (rtList.size() != 1) {
        throw new Exception("Dynamic Query Using Condition failed");
    }
}

다음은 Query 서비스를 정의한 context-query.xml 과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml파일의 일부이다. (* 조회 유형의 쿼리에 대해 페이징 처리를 수행하기 위해서는 해당 DB에 맞는 PagingSQLGenerator를 추가 셋팅해주어야 함에 유의하도록 한다.)

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    <property name="pagingSQLGenerator" ref="pagingSQLGenerator"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>  
<bean id="pagingSQLGenerator" 
        class="org.anyframe.query.impl.jdbc.generator.OraclePagingSQLGenerator"/>  

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
    <config:configuration>
        <filename>classpath:/query/mapping-query-pagination.xml</filename>
    중략...
    </config:configuration>		
</bean>  		

다음은 앞서 정의한 Query 서비스를 통해 로드된 mapping-query-pagination.xml의 일부로, 테이블 매핑 정보와 쿼리문을 포함하고 있다.

<query id="selectUsingPagination">
    <statement>
        SELECT NAME FROM TBL_CUSTOMER WHERE SSNO like ?
    </statement>
    <param type="VARCHAR" />
    <result class="anyframe.sample.domain.Customer"/>
</query>

다음은 앞서 언급한 매핑 XML 파일에 정의된 SELECT 쿼리문을 실행하는 테스트 코드의 일부로, 페이징 처리된 수행 결과를 얻어 내기 위한 테스트 로직을 포함하고 있다.

/**
 * SELECT 수행 결과를 특정 페이지별로 조회하는 테스트 코드
 * 이 메소드에서는 TBL_CUSTOMER 테이블에 여러 데이터가 입력되었을 때, 한 페이지에 표현하고자 
 * 하는 데이터의 개수(5)와 조회 페이지 페이지 번호(3)를 입력하여  특정 페이지에 속한 데이터만 
 * 조회해 본다.
 */
public void selectCustomer() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    /** findWithRowCount() : 매핑 XML 파일에 정의되어 있는 query id를 이용하여 SELECT를
     *                       실행한다. findWithRowCount()는 한번의 호출로 해당 SELECT로 
     *                       얻을 수 있는 전체 데이터의 개수와 특정 페이지에 해당하는
     *                       결과값들을 얻어 올 수 있다.
     */
    HashMap resultMap = queryService.findWithRowCount("selectUsingPagination",
            new Object[] { "%1234%" }, 3, 5);
			
    Customer customer = new Customer();
    Map rsMap = new HashMap();

    // 특정 페이지에 속한 결과값들 추출
    List resultList = (List) resultMap.get(QueryService.LIST);
    for(int i = 0 ; i < resultList.size() ; i ++){
        customer = (Customer)resultList.get(i);
        customer.getNm();
    }  
	
    // 해당 SELECT로 얻어질 수 있는 전체 데이터의 개수 추출
    int totalSize = ((Long) resultMap.get(QueryService.COUNT)).intValue();
    if (resultList.size() != 5 || totalSize != 15) {
        throw new Exception("Select query failed");
    }
}

다음은 Query 서비스에서 제공하는 페이징 처리 기능을 수행하는 findXXX() 메소드 사용시 알아두어야 할 사항들이다. public Collection find...(..., int pageIndex, int pageSize);

다음은 Query 서비스를 정의한 context-query.xml과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml 파일의 일부이다.

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
    <config:configuration>
        <filename>classpath:/query/mapping-query-batch.xml</filename>
        중략...
    </config:configuration>		
</bean>

다음은 앞서 정의한 Query 서비스를 통해 로드된 mapping-query-batch.xml 파일의 일부로, 테이블 매핑 정보와 Batch로 처리할 쿼리문을 포함하고 있다.

<queryservice>
    <table-mapping>
        <table name="TBL_CUSTOMER"
            class="anyframe.sample.domain.Customer">
            <field-mapping>
                <dbms-column>ssno</dbms-column>
                <class-attribute>ssno</class-attribute>
            </field-mapping>
            <field-mapping>
                <dbms-column>name</dbms-column>
                <class-attribute>nm</class-attribute>
            </field-mapping>
            <field-mapping>
                <dbms-column>address</dbms-column>
                <class-attribute>addr</class-attribute>
            </field-mapping>
            <primary-key>
                <dbms-column>ssno</dbms-column>
            </primary-key>
        </table>
    </table-mapping>
    <queries>
        <query id="insertbatch" isDynamic="false">
            <statement>
                INSERT INTO TBL_CUSTOMER ( ssno, name, address ) VALUES (?,?,?)
            </statement>
            <param type="VARCHAR" />
            <param type="VARCHAR" />
            <param type="VARCHAR" />
        </query>
    </queries>
</queryservice>

다음은 앞서 언급한 매핑 XML 파일에 정의된 INSERT 쿼리문을 Batch Update를 이용해 실행하는 테스트 코드의 일부이다. 입력 parameter를 LIST 형태로 담아서 Query 서비스에 전달하면, Query 서비스는 한 번의 실행으로 전달된 List 개수 만큼의 쿼리문을 실행한다.

/**
 * 매핑 XML 파일에 정의된 쿼리문을 batch update를 이용해 실행.
 */
public void insertCustomer() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");

    //ArrayList에 입력할 데이터를 저장한다.
    ArrayList args = new ArrayList();
    Object[] arg = new Object[3];
    arg[0] = "1234567890123";
    arg[1] = "KimMinsu";
    arg[2] = "Ansan";
    args.add(arg);
    arg = new Object[3];
    arg[0] = "1234567890124";
    arg[1] = "LeeSungwook";
    arg[2] = "Seoul";
    args.add(arg);
    arg = new Object[3];
    arg[0] = "1234567890125";
    arg[1] = "ParkHeejin";
    arg[2] = "Seoul";
    args.add(arg);

    //ArrayList에 3개의 Object가 포함되어 있으므로 query id가 insertbatch인
    //쿼리문이 3번 실행된다.
    int[] results = queryService.batchUpdate("insertbatch", args);
    for (int i = 0; i < results.length; i++) {
        if (results[i] == -1) {
            throw new Exception("Batch Insert falied");
        }
    }
}

/**
 * 매핑 XML 파일에 쿼리문이 정의되어 있지 않을 때, 실행할 쿼리문을 직접 입력하여
 * batch update를 실행 
 */
public void insertCustomerBySQLQuery() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
    
    //실행 할 쿼리문을 정의
    String sql = "INSERT INTO TBL_CUSTOMER ( ssno, name, address ) VALUES (?,?,?)";

    //입력할 parameter의 SQL Type을 정의
    String[] types = new String[3];
    types[0] = "VARCHAR";
    types[1] = "VARCHAR";
    types[2] = "VARCHAR";

    //ArrayList에 입력할 데이터를 저장한다.
    ArrayList args = new ArrayList();
    Object[] arg = new Object[3];
    arg[0] = "1234567890126";
    arg[1] = "HongGildong";
    arg[2] = "Suwon";
    args.add(arg);
    arg = new Object[3];
    arg[0] = "1234567890127";
    arg[1] = "LeeSoonsin";
    arg[2] = "Seongnam";
    args.add(arg);
    arg = new Object[3];
    arg[0] = "1234567890128";
    arg[1] = "ChoiMinsu";
    arg[2] = "Seoul";
    args.add(arg);

    //ArrayList에 3개의 Object가 포함되어 있으므로 해당 쿼리문이 3번 실행된다.	
    int[] results = queryService.batchUpdateBySQL(sql, types, args);

    for (int i = 0; i < results.length; i++) {
        if (results[i] == -1) {
            throw new Exception("BatchInsertBySQL falied");
        }
    }
}

/**
 * OR Mapping을 이용해서 batch update를 실행
 */
public void insertCustomerByObject() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");

    ArrayList args = new ArrayList();
    Customer customer = new Customer();

    customer.setSsno("1234567890129");
    customer.setNm("Smith");
    customer.setAddr("LA");
    args.add(customer);

    customer = new Customer();
    customer.setSsno("1234567890130");
    customer.setNm("Brown");
    customer.setAddr("Newyork");
    args.add(customer);

    customer = new Customer();
    customer.setSsno("1234567890131");
    customer.setNm("Eugene");
    customer.setAddr("Boston");
    args.add(customer);

    // 실행되는 쿼리문은 기본적인 INSERT문인
    // insert into TBL_CUSTOMER (ssno ,address ,name ) values ( ?, ?, ? )이다.
    int[] results = queryService.batchCreate(args);

    for (int i = 0; i < results.length; i++) {
        if (results[i] == -1) {
            throw new Exception("BatchInsertByObject falied");
        }
    }
}

다음은 Query 서비스를 정의한 context-query.xml 과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml 파일의 일부이다.

<bean name="oracle_queryservice" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>		
    <property name="sqlRepository" ref="sqlLoader"/>		
    중략...
</bean>	
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
    <config:configuration>
        <filename>classpath:/query/mapping-query-callablestatement.xml</filename>
                중략...
    </config:configuration>		
</bean>

다음은 앞서 정의한 Query 서비스를 통해 로드된 mapping-query-callablestatement.xml 파일의 일부로, DB에 기 생성되어 있는 test_function이라는 Function을 실행시키기 위한 쿼리문을 포함하고 있다.

<queryservice>
    <queries>	
        <query id="callFunction">
            <statement>{? = call test_function(?)}</statement>
            <param type="NUMERIC" binding="OUT" name="outVal" />
            <param type="NUMERIC" binding="IN" name="inVal" />
        </query>
    </queries>    
</queryservice>

다음은 앞서 언급한 매핑 XML 파일에 정의된 Function을 호출하기 위한 쿼리문을 실행하는 테스트 코드의 일부이다. Query 서비스를 통해 DB Function을 실행시키기 위해서는 사용하는 DB에 해당 Function이 미리 생성되어 있어야 한다.

/**
 * 매핑 XML 파일에 정의되어 있는 query id를 이용해 Function을 호출한다.
 */
public void callableStatementFunction() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
	
    HashMap inVal = new HashMap();
    inVal.put("inVal", new Integer(10));
	
    Map results = queryService.execute("callFunction", inVal);
    BigDecimal rtVal = (BigDecimal) results.get("outVal");
	
    if (rtVal.intValue() != 1 ){
        throw new Exception("testCallableStatementProcedure failed");
    }
}

/**
 * 매핑 XML 파일에 정의되어 있지 않은 경우에도 특정 Function을 호출할 수 있다.
 * Map executeBySQL(String sql, String[] types, String[] names,
 *     String[] bindings, Map values) 
 */
public void callableStatementBySQL() throws Exception {
    QueryService queryService = (QueryService) context.getBean("oracle_queryservice");
	
    String sql = "{? = call test_function(?)}";
    String[] types = { "NUMERIC", "NUMERIC" };
    String[] bindings = { "OUT", "IN" };
    String[] names = { "outVal", "inVal" };
	
    HashMap inVal = new HashMap();
    inVal.put("inVal", new Integer(10));
	
    Map results = queryService.executeBySQL(sql, types, names, bindings, inVal);
    BigDecimal rtVal = (BigDecimal) results.get("outVal");

    if (rtVal.intValue() != 1 ){
        throw new Exception("testCallableStatementBySQL failed");
    }
}	

/**
 * 매핑 XML 파일에 정의되어 있지 않은 경우에도 특정 Function을 호출할 수 있다.
 * 이 메소드에서는 페이징 처리된 조회 결과를 얻고자 한다.
 * Map executeBySQL(String sql, String[] types, String[] names, 
 * 					String[] bindings, Map values, int pageIndex, int pageSize) 
 */
public void callableStatementBySQLWithPaging() throws Exception {
    QueryService queryService = (QueryService) context.getBean("oracle_queryservice");
	
    String sql = "{? = call test_function(?)}";
    String[] types = { "NUMERIC", "NUMERIC" };
    String[] bindings = { "OUT", "IN" };
    String[] names = { "outVal", "inVal" };
	
    HashMap inVal = new HashMap();
    inVal.put("inVal", new Integer(10));
	
    Map results = queryService.executeBySQL(sql, types, names, bindings, inVal, 1, 1);
    BigDecimal rtVal = (BigDecimal) results.get("outVal");

    if (rtVal.intValue() != 1 ){
        throw new Exception("testCallableStatementBySQLWithPaging failed");
    }
}

다음은 Query 서비스를 정의한 context-query.xml 과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml 파일의 일부이다.

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
    <config:configuration>
        <filename>classpath:/query/mapping-query-namedparamvo.xml</filename>
        중략...
    </config:configuration>		
</bean>

다음은 앞서 정의한 Query 서비스를 통해 mapping-query-namedparamvo.xml 로, Named Parameter로 전달된 'vo'를 활용한 다양한 쿼리문들을 포함하고 있다. Parameter명이 'vo'인 객체로부터 . 뒤에 붙은 이름에 대한 getter 메소드를 호출한 결과를 PreparedStatement에 셋팅한 후, 해당 쿼리문을 실행하게 된다.

<queryservice>
    <queries>
        <query id="insertCategory">
            <statement>
                INSERT INTO TBL_CATEGORY 
                    (CATEGORY_NO, CATEGORY_NAME, CATEGORY_DESC, USE_YN, REG_ID, 
                    REG_DATE, MODIFY_ID, MODIFY_DATE) 
                VALUES (:vo.categoryNo, :vo.categoryName, :vo.categoryDesc, 
                    :vo.useYn, :vo.regId, sysdate, :vo.regId, sysdate)
            </statement>	
        </query>	
        <query id="updateCategory">
            <statement>
                UPDATE TBL_CATEGORY  
                SET CATEGORY_NAME = :vo.categoryName, 
                    CATEGORY_DESC = :vo.categoryDesc, 
                    USE_YN =:vo.useYn, MODIFY_ID = :vo.modifyId,
                    MODIFY_DATE = sysdate
                WHERE CATEGORY_NO = :vo.categoryNo
            </statement>
        </query>	
        <query id="deleteCategory">
            <statement>
                delete from TBL_CATEGORY where CATEGORY_NO = :vo.categoryNo
            </statement>	
        </query>
        <query id="findCategoryList">
            <statement>
                SELECT CATEGORY_NO, CATEGORY_NAME, CATEGORY_DESC, USE_YN, REG_ID
                FROM TBL_CATEGORY
                WHERE CATEGORY_NO like :vo.categoryNo
            </statement>
            <result class="anyframe.sample.domain.Category"></result>
        </query>
        <query id="findCategory">
            <statement>
                SELECT CATEGORY_NO, CATEGORY_NAME, CATEGORY_DESC, USE_YN, REG_ID
                FROM TBL_CATEGORY
                WHERE CATEGORY_NO = :vo.categoryNo
            </statement>
            <result class="anyframe.sample.domain.Category"></result>
        </query>					
    </queries>
</queryservice>

다음은 앞서 언급한 매핑 XML 파일에 정의된 INSERT, SELECT, UPDATE, DELETE 쿼리문을 실행하는 테스트 코드의 일부이다. Query 서비스에 입력 Parameter 전달시 'vo'라는 Parameter명에 Category 또는 SearchVO 객체를 매핑시키고 있음을 알 수 있다.

/**
 * QueryService에 특정 쿼리의 입력 Parameter값을 전달할 때, named parameter 형태로 transfer
 * object를 전달한다. QueryService에서는 전달받은 객체의 getter 메소드를 호출하여 INSERT
 * 쿼리문의 Parameter값을 셋팅하고 실행한다.
 */
public Category testInsertCategory() throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");

    Category category = makeCategory();
    
    Object[] args = new Object[] { "vo", category };
    int result = queryService.create("insertCategory",
        new Object[] { args });

    if (result != 1) {
        throw new Exception("Insert a new category failed");
    }

    return category;
}

/**
 * QueryService에 특정 쿼리의 입력 Parameter값을 전달할 때, named parameter 형태로 transfer
 * object를 전달한다. QueryService에서는 전달받은 객체의 getter 메소드를 호출하여 UPDATE
 * 쿼리문의 Parameter값을 셋팅하고 실행한다.
 */
public void updateCategory(Category category) throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");
    category.setCategoryName("testUpdate");

    Object[] args = new Object[] { "vo", category };
    int result = queryService.update("updateCategory",
        new Object[] { args });

    if (result != 1) {
        throw new Exception("Update category failed");
    }
}

/**
 * QueryService에 특정 쿼리의 입력 Parameter값을 전달할 때, named parameter 형태로 transfer
 * object를 전달한다. QueryService에서는 전달받은 객체의 getter 메소드를 호출하여 DELETE
 * 쿼리문의 Parameter값을 셋팅하고 실행한다.
 */
public void deleteCategory(Category category) throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");

    Object[] args = new Object[] { "vo", category };
    int result = queryService.remove("deleteCategory",
        new Object[] { args });

    if (result != 1) {
        throw new Exception("Delete category failed");
    }

    args = new Object[] { "vo", category };
    Collection rtCollection = queryService.find("findCategory",
        new Object[] { args });

    if (rtCollection.size() != 0) {
        throw new Exception("Find categorylist failed");
    }
}

/**
 * QueryService에 특정 쿼리의 입력 Parameter값을 전달할 때, named parameter 형태로 transfer
 * object를 전달한다. QueryService에서는 전달받은 객체의 getter 메소드를 호출하여 SELECT
 * 쿼리문의 Parameter값을 셋팅하고 실행한다.
 */
public void findCategory(String categoryNo, String categoryName)
		throws Exception {
    QueryService queryService = (QueryService) context.getBean("queryService");

    Category searchVO = new Category();
    searchVO.setCategoryNo(categoryNo);

    Object[] args = new Object[] { "vo", searchVO };
    Collection rtCollection = queryService.find("findCategory",
        new Object[] { args });

    if (rtCollection.size() != 1) {
        throw new Exception("Find category failed");
    }

    Category category = (Category) rtCollection.iterator().next();
    if (!(categoryNo.equals(category.getCategoryNo()) && categoryName
        .equals(category.getCategoryName()))) {
        throw new Exception("Find category failed");
    }
}

다음은 Query 서비스를 통해 로드된 mapping-query-abstractdao.xml 파일의 일부로, Named Parameter를 포함한 다양한 쿼리문들을 포함하고 있다.

<queryservice>
    <queries>
        <query id="createProduct">
            <statement>
                INSERT INTO PRODUCT 
                    ( PROD_NO, PROD_NAME, SELLER_ID, CATEGORY_NO, PROD_DETAIL, 
                    MANUFACTURE_DAY, AS_YN, SELL_QUANTITY, SELL_AMOUNT, IMAGE_FILE, 
                    REG_DATE ) 
                VALUES (:vo.prodNo, :vo.prodName, :vo.sellerId, :vo.category.categoryNo, 
                    :vo.prodDetail, :vo.manufactureDay, :vo.asYn, :vo.sellQuantity, 
                    :vo.sellAmount, :vo.imageFile, sysdate)
            </statement>
        </query>

        <query id="updateProduct">
            <statement>
                UPDATE PRODUCT 
                SET PROD_NAME = :vo.ProdName,
                    PROD_DETAIL = :vo.prodDetail,
                    MANUFACTURE_DAY = :vo.manufactureDay,
                    AS_YN = :vo.asYn,
                    SELL_QUANTITY = :vo.sellQuantity,
                    SELL_AMOUNT = :vo.sellAmount,
                    REG_DATE = sysdate
                WHERE PROD_NO = :vo.ProdNo
            </statement>
        </query>

        <query id="findProductByPk">
            <statement>
                SELECT	PROD_NO, PROD_NAME, SELLER_ID, CATEGORY_NO, PROD_DETAIL, 
                    MANUFACTURE_DAY, AS_YN, SELL_QUANTITY, SELL_AMOUNT, IMAGE_FILE, 
                    REG_DATE 
                FROM PRODUCT
                WHERE PROD_NO = :vo.ProdNo
            </statement>
            <result class="anyframe.sample.domain.Product">
                <result-mapping column="{CATEGORY_NO}" attribute="{category.categoryNo}" />
            </result>
        </query>

        <query id="removeProduct">
            <statement>
                DELETE FROM PRODUCT 
                WHERE PROD_NO = :vo.prodNo
            </statement>
        </query>

        <query id="findProductList">
            <statement>
                SELECT product.PROD_NO, product.PROD_NAME, product.SELLER_ID, 
                    product.CATEGORY_NO, product.PROD_DETAIL, product.MANUFACTURE_DAY, 
                    product.AS_YN, product.SELL_QUANTITY, product.SELL_AMOUNT, 
                    product.IMAGE_FILE, product.REG_DATE 
                FROM PRODUCT product 
                WHERE 
                    product.PROD_NAME like :vo.prodName
                    AND product.AS_YN = :vo.asYn
                ORDER BY product.PROD_NO DESC
            </statement>
            <result class="anyframe.sample.domain.Product">
                <result-mapping column="{CATEGORY_NO}" attribute="{category.categoryNo}" />
            </result>
        </query>
    </queries>
</queryservice>

다음은 AbstractDao를 상속받아 구현한 ProductDaoImpl.java 클래스의 일부이다. AbstractDao에서 제공하는 메소드를 호출함으로써 Product 정보를 INSERT, UPDATE, DELETE, SELECT하는 역할을 수행하는ProductDaoImpl 로직이 보다 간단해졌음을 알 수 있을 것이다. AbstractDao 클래스를 상속받은 경우 Query 서비스의 API를 직접 호출하려면 getQueryService() 메소드 호출을 통해 Query 서비스를 얻어내어 활용하면 된다.

public class ProductDaoImpl extends AbstractDao {
    // query id가 'createProduct'인 INSERT문을 실행
    public int createProduct(Product vo) throws Exception {
        return create("Product", vo);
    }
	
    // query id가 'deleteProduct'인 DELETE문을 실행
    public int deleteProduct(Product vo) throws Exception {
        return remove("Product", vo);
    }
	
    // query id가 'findProductByPk'인 SELECT문을 실행하고 
    // 조회 결과인 Product 객체를 전달 
    public Product selectProduct(String prodNo) throws Exception {
        Product vo = new Product();
        vo.setProdNo(prodNo);
        Product resultVo = (Product) findByPk("Product", vo);
        return resultVo;
    }
	
    // query id가 'findProductList'인 SELECT문을 실행하고 
    // 조회 결과인 Page 객체를 전달
    public Page selectProductList(Product vo, int pageIndex, int pageSize,
        int pageUnit) throws Exception {
        return findListWithPaging("Product", vo, pageIndex,
                pageSize, pageUnit);
    }
	
    // query id가 'updateProduct'인 UPDATE문을 실행
    public int updateProduct(Product vo) throws Exception {
        return update("Product", vo);
    }
}

다음은 AbstractDao 클래스를 상속받은 ProductDaoImpl 클래스의 속성을 정의한 context-service.xml 파일의 일부이다. AbstractDao 클래스에서 내부적으로 Query 서비스를 사용하므로 Query 서비스의 Bean Id를 속성으로 셋팅해주도록 한다.

<bean id="productDao" class="anyframe.sample.query.sales.dao.impl.ProductDaoImpl">
    <property name="queryService" ref="queryService" />
    <property name="propertiesService" ref="propertiesService" />
</bean>

다음은 앞서 언급한 매핑 XML 파일에 정의된 INSERT, SELECT, UPDATE, DELETE 쿼리문을 실행하는 테스트 코드의 일부이다.

/**
 * AbstractDao를 통해 DB에 신규 데이터를 입력하는 테스트 코드
 */
public void insertProduct() throws Exception {
    Category category = categoryService.get("CATEGORY-00004");
    Product product = new Product();
    product.setProdName("sample.sportsone");
    product.setCategory(category);
    product.setProdDetail("sports one detail");
    product.setSellerId("woos41");
    product.setAsYn("Y");
    product.setManufactureDay("20081225");
    product.setSellAmount(new Long(50));
    product.setSellQuantity(new Long(50));
    
	// 매핑 XML 파일에 정의되어 있는 query id를 이용하여 INSERT를 실행한다.
    productDao.create(product);
}

/**
 * AbstractDao를 통해 DB에 입력된 데이터를 조회하는 테스트 코드
 */
public void selectProduct(String prodNo) throws Exception {
    // 매핑 XML 파일에 정의되어 있는 query id를 이용하여 SELECT를 실행한다.
    Product vo = productDao.get(prodNo);
}

/**
 * AbstractDao를 통해 DB에 입력된 데이터를 페이징 처리하기 위한 테스트 코드
 */
public void selectProductList() throws Exception {
    ProductSearchVO searchVO = new ProductSearchVO();
    searchVO.setSearchCondition("0");
    searchVO.setSearchKeyword("sample.sportsone");
    searchVO.setPageIndex(1);
    searchVO.setPageSize(2);
    
    // 매핑 XML 파일에 정의되어 있는 query id를 이용하여 SELECT를 실행하고,
    // 페이징 처리된 실행 결과를 얻는다.
    Page products = productDao.getPagingList(searchVO);
}

/**
 * AbstractDao를 통해 DB에 입력된 데이터를 수정하는 테스트 코드
 */
public void updateProduct(Product product) throws Exception {
    // 매핑 XML 파일에 정의되어 있는 query id를 이용하여 UPDATE를 실행한다.
    product.setProdName("sportsone-update");
    product.setProdDetail("sports one detail-update");
    
    productDao.update(product);
}

/**
 * AbstractDao를 통해 DB에 입력된 데이터를 삭제하는 테스트 코드
 */
public void deleteProduct(String prodNo) throws Exception {
    // 매핑 XML 파일에 정의되어 있는 query id를 이용하여 DELETE를 실행한다.
    productDao.remove(prodNo);
}					

다음은 Query 서비스를 정의한 context-query.xml 과 Query 서비스에서 읽어들일 매핑 XML 파일의 위치를 정의한 context-query-sqlloader.xml 파일의 일부이다.

<bean id="queryService" class="org.anyframe.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
    중략...
</bean>
<bean id="jdbcTemplate" class="org.anyframe.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean name="sqlLoader" class="org.anyframe.query.impl.config.loader.SQLLoader">
    <config:configuration>
        <filename>classpath:/query/mapping-query-resultsetmapper.xml</filename>
        중략...
    </config:configuration>		
</bean>

다음은 앞서 정의한 Query 서비스를 통해 로드된 mapping-query-resultsetmapper.xml의 일부로, 쿼리문을 포함하고 있다. Query Id가 findCustomerWithResultSetMapper인 쿼리문 실행 결과는 사용자가 정의한 anyframe.sample.query.CustomerMapper를 통해 처리되도록 정의하고 있음을 알 수 있다.

<queries>  		
    <query id="findCustomerWithResultSetMapper" isDynamic="false">
        <statement>select NAME, ADDRESS from TB_CUSTOMER where SSNO like ?</statement>
        <param type="VARCHAR"/>
        <result mapper="anyframe.sample.query.CustomerMapper"/>
    </query>
</queries>

사용자는 다음과 같은 순서로 ResultSetMapper를 구현하면 된다.

다음은 앞서 언급한 매핑 XML 파일에 정의된 CustomerMapper.java의 일부이다.

public class CustomerMapper implements ResultSetMapper {

    public Object mapRow(ResultSet resultSet) throws SQLException {
        Customer customer = new Customer();
        customer.setNm(resultSet.getString("name"));
        customer.setAddr(resultSet.getString("address"));
        return customer;
    }
}

다음은 앞서 언급한 매핑 XML 파일에 정의된 SELECT 쿼리문을 실행하는 테스트 코드의 일부이다.

/**
 * QueryService의 find() 메소드를 호출하여 매핑 XML에 정의된 쿼리문을 실행시키고, 매핑 XML에 정의된
 * IResultSestMapper 유형의 Mapper를 이용하여, 결과값이 매핑되는지 체크하기 위한 테스트 코드
 */
public void findWithCustomResultSetMapper() throws Exception {
    QueryService queryService = (QueryService) context
            .getBean("queryService");

    // execute query
    Collection rtList = queryService.find(
            "findCustomerWithResultSetMapper", new Object[] { "%123456%" });
    // assert a size of result
    if (rtList.size() != 3)
        throw new Exception("Fail to select with custom ResultSetMapper.");

    // assert in detail
    Iterator resultItr = rtList.iterator();
    while (resultItr.hasNext()) {
        Customer customer = (Customer) resultItr.next();
        if (!customer.getAddr().equals("Seoul"))
            throw new Exception("Fail to compare result in defail.");
    }
}