Flex는 기본적으로는 Action Script, MXML, Asset(CSS, Image)로 구성되어 있고 컴파일 된 SWF파일이 플래시 플레이어에서 실행 된다.

MXML파일을 컴파일 하기 위해서는 아래와 같이 Flex SDK에서 제공하는 mxmlc.exe명령어를 이용하면 된다.

mxmlc -file -specs Main.mxml

Flex Builder 3는 Flex개발을 위한 IDE이며, mxmlc와 compc 컴파일러가 포함되어 있어 mxml을 자동으로 컴파일해준다. Flex Builder 3는 독립실행 버전과 Eclipse플러그인 버전이 있다. 독립실행 버전은 별도의 이클립스 설치가 필요 없지만, JDT(Java Development Tools)를 사용 할 수 없다.

Flex Builder 3는 MXML의 자동 컴파일 외에 디버깅, 자동완성, 모니터링 등의 개발 시 필요한 기능들과 컴포넌트 디자인을 쉽게 할 수있도록 디자인 뷰를 제공한다.

BlazeDS의 WEB-INF/flex폴더의 4개의 xml파일(services-config.xml, remoting-config.xml, proxy-config.xml, messaging-config.xml)을 Web Application Project의 {Web Root folder}/WEB-INF/flex란 이름의 폴더를 생성한 후 아래 그림과 같이 복사한다.

service-config.xml 파일을 열어 remoting-config.xml, messaging-config.xml파일의 include 부분을 삭제 또는 주석처리 한다. 두 파일을 include에서 제외하는 이유는 Spring BlazeDS Integration의 설정파일에서 Remoting, Messaging 통신에 대한 환경설정을 할 수 있기 때문이다. 그리고 Web Application 레벨의 default-channels을 설정한다. 아래는 수정된 service-config.xml파일의 일부이다.

<services-config>
    <services>
        <!-- service-include file-path="remoting-config.xml" / -->
        <service-include file-path="proxy-config.xml" />
        <!-- service-include file-path="messaging-config.xml" / -->  
        <default-channels>
        	<channel ref="my-amf"/>
    	</default-channels>      
    </services>

    <security>
    <!-- 중략 -->

BlazeDS의 WEB-INF/lib폴더의 BlazeDS 서버 측 라이브러리를 Web Application Project의 {Web Root folder}/WEB-INF/lib폴더에 복사한다. 이 때 Web Application에 이미 등록되어 있는 라이브러리와 충돌나지 않도록 확인해서 복사한다. 예를들어 Anyframe의 Core Plugin으로 설치된 Web Application에는 common-logging-1.1.1.jar을 포함하고 있으므로 common-logging.jar은 제외한 후 복사한다.

Spring Source Community에서 Spring BlazeDS Integration 1.5.0을 다운 받아 org.springframework.flex-1.5.0.RELEASE.jar파일을 Web Application Project의 {Web Root folder}/WEB-INF/lib에 복사한다.

Spring BlazeDS Integration 라이브러리 복사가 끝났으면, Flex UI에서 RPC요청이 왔을 때 MessageBrokerServlet이 아닌 Spring MVC의 DispatcherServlet이 요청을 처리 할 수 있도록 web.xml파일에 Servlet설정을 아래와 같이 추가 한다. 이 때 Spring MVC에 대한 Servlet설정이 이미 정의되어 있으면 새로운 Servlet을 추가 정의한다.

<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/springmvc/common-servlet.xml,
                    classpath:/springmvc/generation-servlet.xml,	
        </param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
	
<servlet>
    <servlet-name>SpringBlazeDS</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/springmvc/flex-servlet.xml
        </param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
</servlet>

위와 같이 SpringBlazeDS Servlet설정을 완료 한 후 아래와 같이 /messagebroker/*에 대한 요청을 SpringBlazeDS Servlet이 처리 할 수 있도록 servlet-mapping을 정의한다.

<servlet-mapping>
    <servlet-name>SpringBlazeDS</servlet-name>
    <url-pattern>/messagebroker/*</url-pattern>
</servlet-mapping>

Flex Client에서 RemotingService, HTTPProxyService, MessageService의 Request url 패턴은 /messagebroker/*형태이다.

다음 그림과 같이 Flex관련 Spring 설정 파일(flex.xml)을 생성하고, Web Appliaction의 classpath:/spring 하위에 위치시키도록 한다.

flex-servlet.xml 파일을 열어 flex namespace를 사용하기 위해 다음과 같이 xsd를 정의한다.

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:flex="http://www.springframework.org/schema/flex"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	http://www.springframework.org/schema/flex 
	http://www.springframework.org/schema/flex/spring-flex-1.5.xsd">
	
</beans>

BlazeDS 설정 파일인 services-config.xml파일을 읽어 MessageBrokerFactoryBean에 등록할 수 있도록 아래와 같이 flex namespace를 사용해 정의한다.

<flex:message-broker/>

위는 Default설정으로 services-config.xml파일이 classpath 상위에 있을 경우에 사용할 수 있다. 추가적인 설정에 대해서는 Spring BlazeDS Integration Configuration을 참고한다.

BlazeDS 에서는 MessageBrokerServlet 을 front Controller 로 사용하여 Flex client 의 요청을 처리했다. Spring BlazeDS Integration 을 사용하면 Spring MVC 의 DispatcherServlet 이 Flex client 의 요청을 처리한다. 따라서 web.xml 에 아래와 같은 설정을 추가한다.

<servlet>
    <servlet-name>SpringBlazeDS</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/springmvc/flex-servlet.xml</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>SpringBlazeDS</servlet-name>
    <url-pattern>/messagebroker/*</url-pattern>
</servlet-mapping>

Spring BlazeDS Integration에서는 BlazeDS와 Spring과의 연계를 위한 복잡한 환경 설정을 간단히 하기 위해 flex namespace를 제공한다. flex namespace를 사용하기 위해서는 Spring 설정 파일에 다음과 같이 xsd를 정의를 추가한다.

<?xml version="1.0" encoding="UTF-8"?>	
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:flex="http://www.springframework.org/schema/flex" 
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/flex 
        http://www.springframework.org/schema/flex/spring-flex-1.5.xsd">
        
        ...
</bean>

web.xml 파일의 설정에 의해 flex client 의 요청을 DispatcherServlet 이 처리하므로 그 요청을 MessageBroker로 위임해야 한다.

MessageBroker 설정은 flex namespace 추가로 아래와 같이 간단한 설정만으로 가능하다.

<?xml version="1.0" encoding="UTF-8"?>	
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:flex="http://www.springframework.org/schema/flex" 
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/flex 
        http://www.springframework.org/schema/flex/spring-flex-1.5.xsd">
			
    <flex:message-broker />
</beans>

위의 설정의 경우 기본적으로 /WEB-INF/flex/services-config.xml 파일을 참조하게 된다. 설정 파일의 위치가 다를 경우 services-config-path attribute 설정을 통해 변경이 가능하다.

<flex:message-broker services-config-path="classpath*:services-config.xml" />

flex namespace를 사용하지 않을 때에는 아래와 같이 설정한다.

<bean id="messageBroker" 
           class="org.springframework.flex.core.MessageBrokerFactoryBean">
    <property name=""serviceConfigPath" value="classpath*:services-config.xml"/>
</bean>

위 Configuring the Spring DispatcherServlet에서 처럼 /messagebroker/*요청에 대한 servlet-mapping을 별도로 설정하지 않고 모든 요청에 대해서 DispatcherServlet이 처리 할 경우 /messagebroker/*에 대한 요청을 MessageBroker가 처리 하기 위해서는 아래와 같이 SimpleUrlHandlerMapping을 설정한다.

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <value>
        /messagebroker/*=_messageBroker
        </value>
    </property>
</bean>

<bean class="org.springframework.flex.servlet.MessageBrokerHandlerAdapter"/>

위의 SimpleUrlHandlerMapping설정은 flex namespace를 사용할 경우는 아래와 같다.

<flex:message-broker>
    <flex:mapping pattern="/messagebroker/*" />
</flex:message-broker>

Application 레벨의 채널 세팅은 BlazeDS설정 파일인 services-config.xml파일에 services태그 안에 아래와 같이 정의 한다. Flex Client에서 RemotingService에 대해 별도의 채널 설정이 필요없을 경우 my-amf 채널을 이용한다.

<services>
    ..중략
    <default-channels>
        <channel ref="my-amf"/>
    </default-channels>        
</services>

RemotingService에 대해 특정 채널을 이용하고자 할 경우에는 아래와 같이 remoting-service의 default-channels속성에 채널 이름을 등록한다.

<flex:message-broker>
    <flex:message-service
        default-channels="my-amf,my-streaming-amf,my-longpolling-amf,my-polling-amf"/>
</flex:message-broker>

remoting-destination 태그는 Spring Bean 을 Remote 객체로 노출 시킨다.

<bean id="productService" class="flex.samples.product.ProductServiceImpl" />
<flex:remoting-destination ref="productService" />

다음과 같은 설정도 가능 하다.

<bean id="productService" class="flex.samples.product.ProductServiceImpl">
    <flex:remoting-destination />
</bean>

include-methods / exclude-methods 속성을 이용해 method 단위의 제어도 가능하다. include-method / exclude-method를 정의하지 않을 경우 default는 include-method이다.

<flex:remoting-destination ref="productService"
    include-methods="read, update"
    exclude-methods="create, delete"
    channels="my-amf, my-secure-amf" />

@RemotingDestination 을 사용해서도 Spring Bean 을 Remote 객체로 노출이 가능하다.

@Service("productService")
@RemotingDestination
public class ProductServiceImpl implements ProductService {
..중략

@RemotingInclude, @RemotingExclude annotation을 이용해 method별 노출 여부를 설정할 수 있다.

@RemotingInclude
public Category getCategoryList(SearchVO searchVO) throws Exception{
..
}

@RemotingExclude
public void removeCategory(Category category) throws Exception{
...
}

@RemotingDestination annotaion을 이용해 Spring Bean을 노출 할 때 Destination 채널 설정은 아래와 같이 한다.

@Service("categoryService")
@RemotingDestination(channels={"my-amf","my-secure-amf"})
public class CategoryServiceImpl implements CategoryService {

Flex MXML파일에서 HTTPService를 사용하기 위해서는 <mx:HTTPService>를 이용하면 된다. 다음은 HTTPService를 이용해 사용자 인증을 하는 샘플 소스이다.

<mx:HTTPService id="categoryService" method="post" 
    url="../categoryList.do" result="getCtegoryListResult(event)" useProxy="false">
    <mx:request>
        <search_condition>{searchCondition.text}</search_condition>
        <search_keyword>{searchKeyword.text}</search_keyword>
    </mx:request>
</mx:HTTPService>
...중략

private function getCategoryList():void
{
    ...중략
    categoryService.send();
}

위의 소스의 경우 getCategoryList메소드가 호출되면 HTTPService에 설정된 url이 호출되고 request태그 안의 값들을 post방식으로 전달한다. 결과 값은 XML형태로 리턴받고 getCategoryListResult메소드에서 처리한다. HTTPService를 BlazeDS없이 사용할 경우에는 useProxy값을 false로 세팅해야 한다.

WebService를 호출 하기 위한 예는 다음과 같다.

<mx:WebService id="categoryService" 
    wsdl="http://localhost:8080/anyframe.samples.ria.flex/getCategoryList.cfc?wsdl" 
    result="getCategoryListResult(event)" useProxy="false">
    <mx:operation name="getCategoryList">
        <mx:request>
            <search_condition>{searchCondition.text}</search_condition>
        		<search_keyword>{searchKeyword.text}</search_keyword>
        </mx:request>
    </mx:operation>
</mx:WebService>

categoryService.getCategoryList.send()를 실행하게 되면 지정된 wsdl 값을 이용하여 WebService를 호출하게 되고 결과는 getCategoryListResult함수에서 처리한다.

private function getCategoryListResult(event:ResultEvent):void{
    grdCategory.dataProvider = event.result;
}
...중략
<mx:DataGrid id="grdCategory.dataProvider" fontSize="14" width="800"/>

Flex에서 기본으로 제공하는 HTTPService와 MXML의 작성방법은 유사하다. 단 useProxy의 속성 값을 true로 해야하고 url대신 destination 속성 값을 정의한다.

<mx:HTTPService id="categoryService" 
    destination="categoryService" result="getCtegoryListResult(event)" useProxy="true">
    <mx:request>
        <search_condition>{searchCondition.text}</search_condition>
        <search_keyword>{searchKeyword.text}</search_keyword>
	</mx:request>
</mx:HTTPService>
...중략

private function getCategoryList():void
{
    ...중략
    categoryService.send();
}

위와 같이 MXML을 작성 했다면 BlazeDS 설정 파일 중 HTTPProxyService에 대한 설정 파일인 proxy-config.xml파일에 다음과 같이 categoryService란 이름의 destination을 등록한다.

<destinaion id="categoryService">
    <properties>
        <url>anyframe.samples.ria.flex/getCategoryList.do</url>
    </properties>
</destination>

RemotingService를 사용하기 위해서는 BlazeDS 설정 파일(remoting-config.xml)에 아래와 같이 destination을 추가한다.

<service id="remoting-service" 
    class="flex.messaging.services.RemotingService">

    <adapters>
        <adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" 
        	default="true"/>
    </adapters>

    <default-channels>
        <channel ref="my-amf"/>
    </default-channels>
	
    <destination id="categoryService">
        <properties>
            <source>anyframe.sample.flex.category.CategoryService</source>
        </properties>
    </destination>
	
</service>

RemotingService에 등록된 destination을 MXML에서는 RemoteObject를 이용해 호출한다.

<mx:Script>
    import mx.rpc.events.ResultEvent;
		
    private function getCategoryList():void{
        var searchVO:FlexSearchVO = new FlexSearchVO();
        categoryService.getCategoryList(searchVO);
    }
    private function getCategoryListResultHandler(event:ResultEvent):void{
        grdCategory.dataProvider = event.result;	
    }
</mx:Script>
<mx:RemoteObject id="categoryService" destination="categoryService">
    <mx:method name="getCategoryList" result="getCategoryListResultHandler(event)"/>
</mx:RemoteObject>
<mx:DataGrid id="grdCategory"/>
<mx:Button label="getCategoryList" click="getCategoryList()"/>

위의 소스코드는 RemoteObject를 이용해 remoting-config.xml에 등록된 destination의 getCategoryList메소드를 호출하는 예이다.

Spring BlazeDS Integration을 이용하게 될 경우에는 remoting-config.xml파일에 destination을 별도로 등록하지 않고 @RemoteDestination과 같은 annotaion을 사용해 해당 Bean을 직접 destination으로 등록할 수 있다. Spring Bean의 Export방법에 대해서는 Exporting Spring Beans for Flex Remoting을 참고한다.

DataSet은 여러개의 DataRow로 구성되어 있고 고유의 id와 DataSet name, 그리고 Query실행에 필요한 id를 갖고 있다. DataRow는 ObjectProxy객체를 상속 받는다. 각 DataRow는 ROWTYPE를 갖고 있어 데이터가 변경 또는 삭제 되었을 경우 이벤트가 발생해 ROWTYPE값이 변경된다.

<data:DataSet id="dsMain" dataSetName="mainDataSet"
selectQueryId="findMovieList"
insertQueryId="insertMovie"
updateQueryId="updateMovie"
deleteQueryId="deleteMovie"
useChangeInfo="true"/>

서비스 인터페이스는 FlexService를 사용한다. FlexService에는 신규 생성, 수정, 목록 조회, 삭제에 관한 메소드가 선언되어 있고 수정,삭제,신규생성을 한번에 처리하는 메소드도 선언되어 있다.

public interface FlexService {
	
    public List findList(List dataSetList, Map param) throws Exception ;
	
    public Map saveAll(List dataSetList, Map param) throws Exception ;
	
    public Map find(String queryId, DataRow dataRow, Map param )throws Exception;
	
    public Map create(String queryId, DataRow dataRow, Map param )throws Exception;
	
    public Map update(String queryId, DataRow dataRow, Map param )throws Exception;
	
    public Map remove(String queryId, DataRow dataRow, Map param )throws Exception;
}

서비스 구현 클래스는 FlexServiceImpl를 사용하며 다음과 같은 구조로 되어 있다.

public class FlexServiceImpl implements FlexService{

    private FlexDao flexDao;
	
    public List findList(List dataSetList, Map param) throws Exception{
        for(int i=0; i < dataSetList.size() ; i++){
            DataSet ds = (DataSet)dataSetList.get(i);

            String queryId = ds.selectQueryId;

            ds.addAll(flexDao.getList(queryId, param));
        }
        return dataSetList;
    }
	
    public Map saveAll(List dataSetList, Map param) throws Exception {
		
        Map result = new LinkedHashMap();
		
        for(int i=0; i<dataSetList.size(); i++) {
			
            DataSet ds = (DataSet)dataSetList.get(i);
			
            for(int cnt=0; cnt<ds.size(); cnt++) {
                DataRow dr = (DataRow)ds.get(cnt); 
				
                if(dr.ROWTYPE.equals("D")) {
                    String queryId = ds.deleteQueryId;
                    int deleteCnt = flexDao.delete(queryId, dr, param);
                    if(result.containsKey(queryId)) {
                        deleteCnt += ((Integer)result.get(queryId)).intValue();
                    }
                    result.put(queryId, deleteCnt);
                }
            }
			
            for(int cnt=0; cnt<ds.size(); cnt++) {
                DataRow dr = (DataRow)ds.get(cnt); 
                if(dr.ROWTYPE.equals("I")) {
                    String queryId = ds.insertQueryId;
                    Object generatedKey = flexDao.create(queryId, dr, param);
                    int insertCnt = 1;
                    if(result.containsKey(queryId)) {
	                    insertCnt += ((Integer)result.get(queryId)).intValue();
                    }
                    result.put(queryId, insertCnt);
			
                    if(generatedKey != null) {
                    if(result.containsKey("generatedKeys")) {
                        List generatedKeys = (List) result.get("generatedKeys");
                        generatedKeys.add(generatedKey);
                    } else {
                        List generatedKeys = new ArrayList();
                        generatedKeys.add(generatedKey);
                        result.put("generatedKeys", generatedKeys);
                    }
                }
			
                }else if(dr.ROWTYPE.equals("U")) {
                    String queryId = ds.updateQueryId;
                    int updateCnt = flexDao.update(queryId, dr, param);
                    if(result.containsKey(queryId)) {
	                updateCnt += ((Integer)result.get(queryId)).intValue();
                }
                result.put(queryId, updateCnt);
                }
            }
        }
        return result;
	}
	
..중략
}

다음은 BlazeDS의 RemotingService를 이용해 BoardService의 getList메소드를 호출하는 예이다.

<mx:Script>
<![CDATA[
...중략
private function getBoardList(currentPage:int, pageClick:Boolean = false):void {
				
	var searchVO:SearchVO = new SearchVO("Board");
	if ( pageClick ){
		searchVO.searchCondition = condition;
		searchVO.searchKeyword = keyword;
	}else{
		keyword = searchKeyword.text;
		condition = searchCondition.selectedItem.data;
		searchVO.searchKeyword = keyword;
		searchVO.searchCondition = condition;
	}
	searchVO.pageIndex = currentPage;
	boardService.getPagingList(searchVO);
}
private function getBoardListResultHandler(event:ResultEvent):void {
				
	page = event.result as Page;
	plb.totalCount = page.totalCount;
	plb.fetchSize = page.pagesize;
	plb.numPages = page.pageunit;
	plb.currentPage = page.currentPage;
	
	boardList = page.objects as ArrayCollection;
	
	setPageStatus(page);
}
...중략
]]>
</mx:Script>

<mx:RemoteObject id="boardService" destination="boardService" showBusyCursor="true">
    <mx:method name="getPagingList" result="getBoardListResultHandler(event)" fault="ResultHandler.faultMessage(event)"/>
    <mx:method name="saveAll" result="saveAllResultHandler(event)" fault="ResultHandler.faultMessage(event)"/>
</mx:RemoteObject>

boardService.getPagingList(searchVO)가 실행되면 destination으로 등록된 boardService getPagingList메소드가 호출되고 id가 findBoardList인 query가 실행되어 결과 값은 Page객체로 리턴된다.

다음은 Anyframe의 Page클래스와 매핑되는 Page.as클래스이다.

package org.anyframe.pagination
{
    import mx.collections.ArrayCollection;
	
    [RemoteClass(alias="org.anyframe.pagination.Page")]
    public class Page
	{
		
    public var objects:ArrayCollection;

    public var currentPage:int;

    public var totalCount:int;

    public var pageunit:int;

    public var pagesize:int;

    public var maxPage:int;

    public var beginUnitPage:int;

    public var endUnitPage:int;
	}
}

BoardService saveAll메소드는 Flex의 DataGrid를 이용해 Data를 추가, 삭제, 수정 한 후 한번의 Service호출로 화면에서 작업했던 Data를 DB에 반영할 때 사용한다.

DataGrid에서 수정, 삭제, 추가 이벤트가 발생할 경우 Board객체의 status값을 변경한다.

//DataGrid의 Row가 추가 됐을 때 실행되는 메소드
private function addBoard():void{
    var addBoard:Board = new Board();
	addBoard.status = 1;
	addBoard.regDate = Util.getToday();
	addBoard.regId = parentDocument.loginUser.userId;
	grdBoard.dataProvider.addItem(addBoard);
}
//DataGird의 Row가 수정 됐을 때 실행되는 메소드
private function updateBoard(event:DataGridEvent):void{
    if (event.reason == DataGridEventReason.CANCELLED){
        return;
    }
            
    var updateBoard:Board = grdBoard.itemEditorInstance.data as Board;

    var rowStatus:Number = updateBoard.status;

    if( rowStatus == 0 ){
	    updateBoard.status = 2;
    }
}
//DataGrid의 Row가 삭제 되었을 때 실행되는 메소드
//삭제된 ASObject를 deleteBoardList에 임시로 저장한다.
private function deleteBoard():void{
    if(grdBoard.selectedIndex != -1){
        var deleteBoard:Board = grdBoard.selectedItem as Board;
        var rowStatus:int = deleteBoard.status;

        if (rowStatus != 1){
            deleteBoard.status = 3;
            deleteBoardList.addItem(deleteBoard)
        }
        grdBoard.dataProvider.removeItemAt(grdBoard.selectedIndex);
    }
}

다음은 boardService의 saveAll메소드를 호출한 후 결과를 처리하는 ActionScript이다.

//DataGrid에서 Binding Data중 status값이
// 0이 아닌 것과 deleteBoardList에 저장 된 DataGrid에서 삭제된 Data를
// saveBoardList에 추가해 BoardList의 saveAll메소드를 호출한다. 
private function saveBoard():void{
    var saveBoardList:ArrayCollection = new ArrayCollection();
    for ( var j:int = 0 ; j < deleteBoardList.length ; j ++ ){
        saveBoardList.addItem(deleteBoardList.getItemAt(j));
    }
    for ( var i:int = 0 ; i < boardList.length ; i ++ ){
        var board:Board = boardList.getItemAt(i) as Board;
        if(board.status != 0){
            if(board.communityId == null){
                Alert.show( "글 " + board.title + "의 커뮤니티를 선택 하지 않았습니다.");
                return;
            }else if(board.title == null) {
            Alert.show( "Title을 입력하지 않은 글이 있습니다.");
            }else{
            saveBoardList.addItem(board);
            }
        }
    }
    if ( saveBoardList.length == 0 ){
        Alert.show( "변경된 데이터가 없습니다." );
    }else{
    boardService.saveAll(saveBoardList);
    }
}
// saveAll메소드의 호출 결과는 추가, 수정, 삭제된 Row수가 담긴 Map형태이다.
// saveAllResultHandler에서는 saveAll메소드의 실행결과를 Alert창을 통해 보여준다.
private function saveAllResultHandler(event:ResultEvent):void{
    var resultArray:Array = ["INSERT", "UPDATE", "DELETE"];
			
    var message:String = "";
    for ( var i:int = 0 ; i < 3 ; i ++ ){
        var count:int = event.result[resultArray[i]];
        message = message + count + " Row가 " + resultArray[i] + "\n";
    }
    message = message + "되었습니다.";

    mx.controls.Alert.show(message);
    deleteBoardList.removeAll();
    getBoardList(1);
}