다음은 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.example.domain.Customer"/>와 같이 table mapping시 정의한 클래스를 이용하면 쿼리문 수행 결과는 해당 클래스의 setter 호출을 통해 저장되고, getter를 호출함으로써 결과값을 얻을 수 있게 된다.

<queryservice>
    <table-mapping>
        <table name="TBL_CUSTOMER"
            class="anyframe.example.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.example.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.example.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.example.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{
	IQueryService queryService = (IQueryService) 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="anyframe.core.query.impl.QueryServiceImpl">
	<property name="jdbcTemplate" ref="jdbcTemplate"/>
	<property name="sqlRepository" ref="sqlLoader"/>
	중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean> 			

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

/**
 * 테스트 코드를 샐행하기 위한 data table 생성
 */
public void insertCustomer() throws Exception{
	IQueryService queryService = (IQueryService) 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{
	IQueryService queryService = (IQueryService) 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{
	IQueryService queryService = (IQueryService) 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{
	IQueryService queryService = (IQueryService) 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="anyframe.core.query.impl.QueryServiceImpl">
	<property name="jdbcTemplate" ref="jdbcTemplate"/>
	<property name="sqlRepository" ref="sqlLoader"/>
	중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
  <property name="dataSource" ref="dataSource" />
</bean> 			

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

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

<queryservice>
    <table-mapping>
        <table name="TBL_ORMapping"
            class="anyframe.example.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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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="anyframe.core.query.impl.QueryServiceImpl">
	<property name="jdbcTemplate" ref="jdbcTemplate"/>
	<property name="sqlRepository" ref="sqlLoader"/>
	중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>          

<bean name="sqlLoader" class="anyframe.core.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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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="anyframe.core.query.impl.QueryServiceImpl">
	<property name="jdbcTemplate" ref="jdbcTemplate"/>
	<property name="sqlRepository" ref="sqlLoader"/>
	<property name="pagingSQLGenerator" ref="pagingSQLGenerator"/>
	중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>  
<bean id="pagingSQLGenerator" class="anyframe.core.query.impl.jdbc.generator.OraclePagingSQLGenerator"/>  

<bean name="sqlLoader" class="anyframe.core.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.example.domain.Customer"/>
</query>		

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

/**
 * SELECT 수행 결과를 특정 페이지별로 조회하는 테스트 코드
 * 이 메소드에서는 TBL_CUSTOMER 테이블에 여러 데이터가 입력되었을 때, 한 페이지에 표현하고자 하는 데이터의 개수(5)와 
 * 조회 페이지 페이지 번호(3)를 입력하여  특정 페이지에 속한 데이터만 조회해 본다. 
 */
public void selectCustomer() throws Exception {
    IQueryService queryService = (IQueryService) 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(IQueryService.LIST);
    for(int i = 0 ; i < resultList.size() ; i ++){
        customer = (Customer)resultList.get(i);
        customer.getNm();
    }  
	
    // 해당 SELECT로 얻어질 수 있는 전체 데이터의 개수 추출
    int totalSize = ((Long) resultMap.get(IQueryService.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="anyframe.core.query.impl.QueryServiceImpl">
	<property name="jdbcTemplate" ref="jdbcTemplate"/>
	<property name="sqlRepository" ref="sqlLoader"/>
	중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>  		

<bean name="sqlLoader" class="anyframe.core.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.example.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">
            <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 {
    IQueryService queryService = (IQueryService) 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 {
    IQueryService queryService = (IQueryService) 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 {
    IQueryService queryService = (IQueryService) 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="anyframe.core.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>		
    <property name="sqlRepository" ref="sqlLoader"/>		
	중략...
</bean>	
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>  		

<bean name="sqlLoader" class="anyframe.core.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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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 {
	IQueryService queryService = (IQueryService) 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="anyframe.core.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
        중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>				

<bean name="sqlLoader" class="anyframe.core.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 = <emphasis role="bold">:vo.categoryName,</emphasis> 
                    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.example.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.example.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 {
    IQueryService queryService = (IQueryService) 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 {
    IQueryService queryService = (IQueryService) 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 {
    IQueryService queryService = (IQueryService) 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 {
    IQueryService queryService = (IQueryService) 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.example.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.example.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.example.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("example.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("example.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="anyframe.core.query.impl.QueryServiceImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
        중략...
</bean>
<bean id="jdbcTemplate" class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>			

<bean name="sqlLoader" class="anyframe.core.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.example.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.example.query.CustomerMapper"/>
	</query>
</queries>		

<result>의 mapper는 신규 추가된 속성으로 http://www.anyframejava.org/dtd/anyframe-core-query-mapping-3.2.dtd에 정의되어 있다. 따라서, mapper를 정의하기 위해서 매핑 XML 파일 헤더에 DTD 위치를 다음과 같이 정의해 주어야 함에 유의하도록 한다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE queryservice PUBLIC "-//ANYFRAME//DTD QUERYSERVICE//EN"
"http://www.anyframejava.org/dtd/anyframe-core-query-mapping-3.2.dtd">
<queryservice>
중략...
</queryservice>	

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

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

public class CustomerMapper implements IResultSetMapper {

	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 {
	IQueryService queryService = (IQueryService) 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.");
	}
}					

다음은 MiPQueryService를 정의한 context-miplatform-query.xml 파일의 일부이다. MiPQueryService는 내부적으로 RiaQueryService를 통해 데이터 접근 처리를 수행하므로 RiaQueryService에 대한 참조 관계 설정이 필요하다.

<bean id="mipQueryService" 
    class="anyframe.core.query.ria.mip.impl.MiPQueryServiceImpl">
    <property name="riaQueryService" ref="riaQueryService"/>
</bean> 

<bean name="riaQueryService" class="anyframe.core.query.ria.impl.RiaQueryServiceImpl">
    <property name="jdbcTemplate" ref="pagingNamedParamJdbcTemplate"/>
    <property name="sqlRepository" ref="mipSqlLoader"/>
        중략...
</bean>

<bean id="pagingNamedParamJdbcTemplate" 
    class="anyframe.core.query.impl.jdbc.PagingNamedParamJdbcTemplate">
    <constructor-arg index="0" ref="pagingJdbcTemplate"/>
    <constructor-arg index="1" ref="dataSource"/>
</bean>

<bean id="pagingJdbcTemplate"
    class="anyframe.core.query.impl.jdbc.PagingJdbcTemplate">
    <constructor-arg ref="dataSource"/>
    <property name="exceptionTranslator" ref="exceptionTranslator"/>
    <property name="paginationSQLGetter" ref="pagingSQLGenerator"/>	
</bean>			

다음은 앞서 정의한 MipQueryService가 참조하는 RiaQueryService Bean을 통해 로드된 mapping-query-mip.xml 파일의 일부로, Named Parameter를 이용한 쿼리문들을 포함하고 있다.

<queries>
    <query id="createProduct" isDynamic="true" mappingStyle="upper">
        <statement>
            INSERT INTO PRODUCT ( 			
                PROD_NO, AS_YN, CATEGORY_NO, IMAGE_FILE, MANUFACTURE_DAY, 
                PROD_DETAIL, PROD_NAME, REG_DATE, SELL_AMOUNT, SELL_QUANTITY, SELLER_ID) 
            VALUES (:PROD_NO, :AS_YN, :CATEGORY_NO, :IMAGE_FILE, :MANUFACTURE_DAY, 
                :PROD_DETAIL, :PROD_NAME, sysdate, :SELL_AMOUNT, :SELL_QUANTITY, :SELLER_ID)
        </statement>
    </query>
		
    <query id="updateProduct" isDynamic="true" mappingStyle="upper">
        <statement>
            UPDATE PRODUCT
            SET 
                PROD_NAME = :PROD_NAME, PROD_DETAIL = :PROD_DETAIL,
                MANUFACTURE_DAY = :MANUFACTURE_DAY, AS_YN = :AS_YN, 
                IMAGE_FILE = :IMAGE_FILE, SELL_QUANTITY = :SELL_QUANTITY,   
                SELL_AMOUNT = :SELL_AMOUNT, CATEGORY_NO = :CATEGORY_NO
            WHERE
                PROD_NO = :PROD_NO 
        </statement>
    </query>
	
    <query id="removeProduct" isDynamic="true" mappingStyle="upper"> 
        <statement>
            DELETE FROM PRODUCT 
            WHERE 
                PROD_NO = :PROD_NO
        </statement>
    </query>
	
    <query id="findProductByPk" isDynamic="true" mappingStyle="upper">
        <statement>
            SELECT 
                PROD_NO, AS_YN, CATEGORY_NO, IMAGE_FILE, MANUFACTURE_DAY, 
                PROD_DETAIL, PROD_NAME, REG_DATE, SELL_AMOUNT, SELL_QUANTITY, 
                SELLER_ID
            FROM PRODUCT
            WHERE 
                PROD_NO = :PROD_NO
        </statement>							
    </query>

    <query id="findProductList" isDynamic="true" mappingStyle="upper">
        <statement>
            SELECT 
                PROD_NO, AS_YN, CATEGORY_NO, IMAGE_FILE, MANUFACTURE_DAY, 
                PROD_DETAIL, PROD_NAME, REG_DATE, SELL_AMOUNT, SELL_QUANTITY, 
                SELLER_ID 
            FROM PRODUCT
            WHERE 		
                PROD_NAME like '%' || :SEARCH_PROD_NAME || '%'
                AND	AS_YN = :SEARCH_AS_YN 
            ORDER BY PROD_NO
        </statement>		
    </query>
</quereis>		

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

/**
 * MiPlatform용 Query 서비스를 통해 DB에 신규 데이터를 입력하는 테스트 코드
 */    
public void insertDataSet() throws Exception {
    IMiPQueryService mipQueryService = (IMiPQueryService) context.getBean("mipQueryService");

    Map queryMap = new HashMap();
    queryMap.put(IMiPQueryService.QUERY_INSERT, "createProduct");

    // INSERT, UPDATE, DELETE 유형별로 사용할 query id를 정의한 Map과 DB에 반영해야 할 
    // Dataset을 전달. Dataset에는 다수의 데이터를 저장할 수 있음.
    int resultInsert =
        mipQueryService.update(queryMap, makeProduct());
}

/**
 * MiPlatform용 Query 서비스를 통해 DB에 입력된 데이터를 수정하는 테스트 코드
 */   
public void updateDataSet() throws Exception {
    IMiPQueryService mipQueryService =
        (IMiPQueryService) context.getBean("mipQueryService");

    Map queryMap = new HashMap();
    queryMap.put(IMiPQueryService.QUERY_UPDATE, "updateProduct");
    
    // INSERT, UPDATE, DELETE 유형별로 사용할 query id를 정의한 Map과 DB에 반영해야 할 
    // Dataset을 전달. Dataset에는 다수의 데이터를 저장할 수 있음.    
    int resultUpdate =
        mipQueryService.update(queryMap, makeProduct());
}

/**
 * MiPlatform용 Query 서비스를 통해 DB에 데이터를 입력/수정/삭제하는 테스트 코드
 */    
public void processAllDataSet() throws Exception {
    IMiPQueryService mipQueryService =
        (IMiPQueryService) context.getBean("mipQueryService");

    Map queryMap = new HashMap();
    queryMap.put(IMiPQueryService.QUERY_UPDATE, "updateProduct");
    queryMap.put(IMiPQueryService.QUERY_INSERT, "createProduct");
    queryMap.put(IMiPQueryService.QUERY_DELETE, "removeProduct");
    
    // INSERT, UPDATE, DELETE 유형별로 사용할 query id를 정의한 Map과 DB에 반영해야 할
    // Dataset을 전달. Dataset에는 다수의 데이터를 저장할 수 있음.            
    int resultUpdate = mipQueryService.update(queryMap, makeProducts());
}

/**
 * MiPlatform용 Query 서비스를 통해 DB에 데이터를 입력/수정/삭제하는 테스트 코드
 * 이때, ActionCommand를 통해 전후처리 수행
 */    
public void processAllDataSetWithActionCommand() throws Exception {
    IMiPQueryService mipQueryService =
        (IMiPQueryService) context.getBean("mipQueryService");

    Map queryMap = new HashMap();
    queryMap.put(IMiPQueryService.QUERY_UPDATE, "updateProduct");
    queryMap.put(IMiPQueryService.QUERY_INSERT, "createProduct");
    queryMap.put(IMiPQueryService.QUERY_DELETE, "removeProduct");
    
    // INSERT, UPDATE, DELETE 유형별로 사용할 query id를 정의한 Map, DB에 반영해야 할 
    // Dataset, DB에 접근하기 전과 후에 처리해야 할 작업을 정의한 ActionCommand를 전달
    // Dataset에는 다수의 데이터를 저장할 수 있음.     
    int resultUpdate =
         mipQueryService.update(queryMap, makeProducts(),
        new ProductActionCommand());
}

/**
 * MiPlatform용 Query 서비스를 통해 DB에 데이터를 조회하는 테스트 코드
 * 이때, 검색조건은 VariableList 형태임
 */     
public void findDataSetWithVariant() throws Exception {
    IMiPQueryService mipQueryService =
        (IMiPQueryService) context.getBean("mipQueryService");

    // 실행할 query id와 VariableList 형태의 검색 조건을 전달
    Dataset resultDataSet =
        mipQueryService.search("findProductByPk", makeVariantList());
}

/**
 * MiPlatform용 Query 서비스를 통해 DB에 데이터를 조회하는 테스트 코드
 * 이때, 검색조건은 Dataset 형태임
 */    
public void findListDataSet(int expected) throws Exception {
    IMiPQueryService mipQueryService =
        (IMiPQueryService) context.getBean("mipQueryService");
    
    // 실행할 query id와 Dataset 형태의 검색 조건을 전달    
    Dataset resultDataSet =
        mipQueryService.search("findProductList",
        makeSearchCondition());
}					

위 소스 코드 중 testProcessAllDataSetWithActionCommand() 메소드에서는 ActionCommand를 이용하여 DB에 데이터를 입력하기 전에 특정 칼럼의 값을 변경하고 있다. 이와 같이 MiPQueryService는 anyframe.core.query.ria.mip.IMiPActionCommand를 구현한 별도 ActionCommand를 인자로 함께 전달하는 경우 입력 데이터를 DB에 반영하기 전/후에 대한 공통 처리를 수행할 수 있도록 지원한다. 예를 들어 입력받은 개별 Row를 DB에 신규 등록하기 전에 신규 식별자 값이 셋팅되어야 한다면, Loop을 돌면서 각 Row를 추출한 뒤 식별자를 셋팅하는 별도 로직없이 preInsert() 로직 내에 식별자 생성 구문이 추가된 ActionCommand 객체만 전달하면 되는 것이다.

다음은 RiaQueryService를 정의한 context-query.xml 파일의 일부이다. RiaQueryService 기본 Query 서비스를 확장하고 있으므로 Query 서비스 속성 정의 방법과 동일하게 속성을 정의해주면 된다.

 <bean id="pagingNamedParamJdbcTemplate" 
    class="anyframe.core.query.impl.jdbc.PagingNamedParamJdbcTemplate">
    <constructor-arg index="0" ref="pagingJdbcTemplate"/>
    <constructor-arg index="1" ref="dataSource"/>
</bean>
   
<bean name="riaQueryService" class="anyframe.core.query.ria.impl.RiaQueryServiceImpl">
    <property name="jdbcTemplate" ref="pagingNamedParamJdbcTemplate"/>
    <property name="sqlRepository" ref="sqlLoader"/>
</bean>