지돌스타 - 쿠키랩 블로그

1. Binary 타입 데이터를 DB에 저장하는 것에 대해
바이너리(Binary) 타입의 데이터를 DB에 저장한다는 것은 가령, 이미지나 사운드와 같은 데이터를 DB에 저장한다는 의미로 해석하면 편하다.

Binary파일을 DB에 넣을때 어떤 형태로 넣을 수 있을까? 

한가지 예는 익히 잘 알고 있는 Base64로 치환해서 text형태로 넣는 방식을 생각해볼 수 있다. Base64는 ASCII코드로 화면에 출력할 수 있는 64개 문자(ABCD...89+/e등)을 이용해 Binary 데이터를 Text로 표현해준다. 하지만 이 방식의 단점은 데이타를 64진수로 표현한 문자열이기 때문에 용량이 필연적으로 커지고 또 encode/decode를 해야하는 부담이 존재한다. base 64에 대해서 알고 싶다면 다음 링크를 보자.

• Base 64 - Wikipedia 
• 이미지 파일을 Base64로 인코딩하기

• ByteArray를 String으로 변환해보자.

• ByteArray를 문자열로 만들기

• Eclipse Galileo에서 C,C++ 개발환경 구축하기 - CDT, MinGW 
• Eclipse, MinGW, CDT 환경에서 C/C++과 MySQL 연동
  

mysql> describe images;
+-------+------------+------+-----+---------+-------+
| Field | Type       | Null | Key | Default | Extra |
+-------+------------+------+-----+---------+-------+
| id    | int(11)    | NO   | PRI |         |       |
| data  | mediumblob | YES  |     | NULL    |       |
+-------+------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

CREATE TABLE `images` (
  `id` int(11) NOT NULL auto_increment,
  `data` mediumblob,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

#define SOCKET int

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mysql/mysql.h>

#define DB_HOST "localhost or ip or domain"
#define DB_USER "DB 접속 ID"
#define DB_PASS "DB 접속 password"
#define DB_NAME "데이타베이스 이름"

int main(void) {
	MYSQL *connection, conn;
	FILE *fp;
	unsigned long len, file_size;
	int query_stat;
	char *buf , *buf_to, *query, *stat = "INSERT INTO images(data) VALUES('%s')";

	//DB 초기화 및 접속
	mysql_init(&conn);
	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306, (char*)NULL, 0);
	if(connection==NULL) {
		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
		return EXIT_FAILURE;
	} else {
		printf("Mysql connected\n");
	}

	//이미지를 불러오기
	fp = fopen("d:/image.png", "rb");
	if(fp==NULL) {
		fprintf(stderr, "image open error");
		mysql_close(connection);
		return EXIT_FAILURE;
	}
	rewind(fp);
	fseek(fp,0,SEEK_END);
	file_size = ftell(fp); //파일의 사이즈를 찾음
	fseek(fp,0,SEEK_SET);
	buf = (char*)malloc(file_size);
	fread(buf, sizeof(char), file_size, fp); //파일을 읽어와 buf에 참고
	fclose(fp);

	//이미지내 escape string 적용
	buf_to = (char*)malloc(file_size*2+1);
	mysql_real_escape_string(connection, buf_to, buf, file_size); 

	//Query 문 작성
	query = (char*)malloc(strlen(stat)+file_size*2+1);
	len = snprintf(query, strlen(stat)+file_size*2+1, stat, buf_to); 

	//Query 문 실행
	query_stat = mysql_real_query(connection, query, len); 
	if(query_stat != 0) {
		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
	}

	//할당한 메모리 반환
	free(buf);
	free(buf_to);
	free(query);

	//DB 커넥션 닫기
	mysql_close(connection);
	return EXIT_SUCCESS;
}

• mysql_real_escape_string() 함수

• 안전한 null-terminated 문자열 복사

• mysql_real_query() 함수

#define SOCKET int

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mysql/mysql.h>

#define DB_HOST "localhost or ip or domain"
#define DB_USER "DB 접속 ID"
#define DB_PASS "DB 접속 password"
#define DB_NAME "데이타베이스 이름"

int main(void) {
	MYSQL *connection, conn;
	MYSQL_RES *result;
	MYSQL_ROW row;
	FILE *fp;
	int query_stat;
	unsigned long *lengths;

	//DB 초기화 및 접속
	mysql_init(&conn);
	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306, (char*)NULL, 0);
	if(connection==NULL) {
		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
		return EXIT_FAILURE;
	} else {
		printf("Mysql connected\n");
	}

	//Query문 수행
	query_stat = mysql_query(connection,"SELECT data FROM images WHERE id=1");
	if(query_stat != 0) {
		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
		return EXIT_FAILURE;
	}

	//Query문 수행한 결과를 통해 데이터 참조
	result = mysql_store_result(connection);
	if(result == NULL) {
		fprintf(stderr, "result is null\n");
		return EXIT_FAILURE;
	}
	row = mysql_fetch_row(result);
	lengths = mysql_fetch_lengths(result);
	mysql_free_result(result);
	printf("file lengths : %ld\n", lengths[0]);

	//이미지 저장
	fp = fopen("d:/savedImage.png", "wb");
	if(fp==NULL) {
		fprintf(stderr, "image save error");
		mysql_close(connection);
		return EXIT_FAILURE;
	}
	fwrite(row[0], lengths[0], 1, fp);
	fclose(fp);

	//DB 커넥션 닫기
	mysql_close(connection);
	return EXIT_SUCCESS;
}

#include <stdio.h>
#include <stdlib.h>

//#pragma pack(1) //struct member alignment를 1로 설정, 기본 설정이 8이라면 이것으로 20->19로 줄인다.
typedef struct st_person {
	unsigned __int16 user_id; //id, 2bytes 정수
	char user_name[15]; //이름, 15bytes 캐릭터형
	unsigned __int16 age; //나이, 2bytes 정수형

}PERSON;
//#pragma pack() //struct member alignment 원상복구

int main(void) {
	printf("struct PERSON size : %d\n",sizeof(PERSON));
	return EXIT_SUCCESS;
}

• struct member alignment에 대해

CREATE TABLE `persons` (
  `AREA` int(11) NOT NULL auto_increment,
  `COUNT` smallint(5) unsigned default NULL,
  `DATA` blob NOT NULL,
  PRIMARY KEY  (`AREA`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

#define SOCKET int

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <mysql/mysql.h>

#define DB_HOST "localhost or ip or domain"
#define DB_USER "DB 접속 ID"
#define DB_PASS "DB 접속 password"
#define DB_NAME "데이타베이스 이름"

#define TABLE_NAME "persons"
#define SQL_DROP_TABLE "DROP TABLE IF EXISTS %s"
#define SQL_CREATE_TABLE "CREATE TABLE `%s` (\
`AREA` int NOT NULL AUTO_INCREMENT,\
`COUNT` smallint unsigned,\
`DATA` BLOB NOT NULL,\
PRIMARY KEY(`AREA`)\
) ENGINE=MyISAM DEFAULT CHARSET=utf8"
#define SQL_INSERT_DATA "INSERT INTO %s(DATA,COUNT) values('%s',%d)"
#define SQL_SELECT_DATA "SELECT `DATA`, `COUNT` FROM %s WHERE `AREA`=%d"

#pragma pack(1) //struct member alignment를 1로 설정, 기본 설정이 8이라면 이것으로 20->19로 줄인다.
typedef struct st_person {
	unsigned __int16 user_id; //id, 2bytes 정수
	char user_name[15]; //이름, 15bytes 캐릭터형
	unsigned __int16 age; //나이, 2bytes 정수형

}PERSON;
#pragma pack() //struct member alignment 원상복구

int connect();
int close();
int create_table();
int drop_table();
PERSON* add_data(PERSON *person_list, int index, unsigned __int16 user_id, unsigned __int16 age, char* user_name);
int remove_all_data(PERSON* person_list);
int insert_data(PERSON* person_list, int count);
int select_data(int area);

MYSQL *connection, conn;

int main(void) {
	printf("PERSON struct size : %d\n",sizeof(PERSON));
	connect();
	drop_table();
	create_table();

	PERSON *person_list;
	person_list = add_data(NULL,0,1,30,"jidolstar");
	person_list = add_data(person_list,1,2,22,"joykim");
	person_list = add_data(person_list,2,3,2,"tae hyun");
	insert_data(person_list,3);
	free(person_list);
	select_data(1);

	person_list = add_data(NULL,0,4,30,"addlayer");
	person_list = add_data(person_list,1,5,22,"eye");
	person_list = add_data(person_list,2,6,2,"unclejoe");
	person_list = add_data(person_list,3,7,3,"miracle");
	insert_data(person_list,4);
	free(person_list);
	select_data(2);


	close();
	return EXIT_SUCCESS;
}

/**
 * DB 접속
 */
int connect() {
	// mysql 초기화
	mysql_init(&conn);

	// DB 연결
	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306, (char*)NULL, 0);
	if(connection==NULL) {
		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
		exit(0);
	} else {
		printf("Mysql connected\n");
	}
	return 0;
}
/**
 * 데이타 베이스 닫음
 */
int close() {
	mysql_close(connection);
	printf("mysql closed\n");
	return 1;
}

/**
 * 테이블 생성
 */
int create_table() {
	int query_stat;
	char buff[1024];

	memset(buff,0x00,sizeof(buff));
	sprintf( buff, SQL_CREATE_TABLE, TABLE_NAME );
	query_stat = mysql_query(connection,buff);
	if( query_stat != 0 ) {
		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
		exit(0);
	} else {
		printf("created table\n");
	}
	return 0;
}

/**
 * 기존 테이블 삭제
 */
int drop_table() {
	int query_stat;
	char buff[1024];

	//기존 테이블 삭제
	memset(buff,0x00,sizeof(buff));
	sprintf( buff, SQL_DROP_TABLE, TABLE_NAME );
	query_stat = mysql_query(connection,buff);
	if( query_stat != 0 ) {
		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
		exit(0);
	} else {
		printf("table dropped\n");
	}
	return 0;
}

/**
 * 데이터 추가
 */
PERSON* add_data(PERSON *person_list, int index, unsigned __int16 user_id, unsigned __int16 age, char* user_name) {
	PERSON *current;
	if(person_list == NULL ) {
		person_list = (PERSON*)malloc(sizeof(PERSON));
		current = person_list;
	} else {
		person_list = (PERSON*)realloc(person_list, sizeof(PERSON)*(index+1));
		current = person_list + index;
	}
	current->user_id = user_id;
	current->age = age;
	memset(current->user_name,0x00,sizeof(current->user_name));
	strcpy(current->user_name,user_name);
	//printf("added user_id:%d, age:%d, name:%s\n",current->user_id,current->age,current->user_name);
	return person_list;
}

/**
 * 모든 데이터 삭제
 */
int remove_all_data(PERSON* person_list) {
	free(person_list);
	return 0;
}

/**
 * 데이타를 디비 테이블에 삽입
 */
int insert_data(PERSON* person_list, int count) {
	int query_stat;
	unsigned long len, size;
	char *buf_to, *query;

	size = sizeof(PERSON)*count*2+1;
	buf_to = (char*)malloc(size);
	mysql_real_escape_string(connection, buf_to, (char*)person_list, sizeof(PERSON)*count);

	//Query 문 작성
	query = (char*)malloc(sizeof(SQL_INSERT_DATA)+size);
	len = snprintf(query, sizeof(SQL_INSERT_DATA)+size, SQL_INSERT_DATA, TABLE_NAME, (char*)buf_to, count );

	//Query 문 실행
	query_stat = mysql_real_query(connection, query, len);
	if(query_stat != 0) {
		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
	} else {
		printf("insert complete\n");
	}

	//할당한 메모리 반환
	free(buf_to);
	free(query);
	return 0;
}

/**
 * 데이타를 디비에서 읽어옴
 */
int select_data(int area) {
	char query[1024];
	int query_stat;
	int count=0;
	int i;
	PERSON *person_list, *person;
	MYSQL_RES *result;
	MYSQL_ROW row;

	memset(query,0x00,sizeof(query));
	sprintf(query, SQL_SELECT_DATA, TABLE_NAME, area);
	query_stat = mysql_query(connection,query);
	if(query_stat != 0) {
		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
		exit(0);
	}

	//갯수만큼 화면에 데이터 출력
	result=mysql_store_result(connection);
	row = mysql_fetch_row(result);
	mysql_free_result(result);
	count = atoi(row[1]); //갯수
	person_list = (PERSON*)row[0]; //한개의  데이터
	for( i=0; i<count; i++ ) {
		person = person_list + i;
		printf("user_id:%d, age:%d, name:%s\n",person->user_id,person->age,person->user_name);
	}
	free(person_list);
	return 0;
}

package com.jidolstar.person.domain;

public class PersonArea {
	private int area;
	private int count;
	private byte[] data;
	
	public int getArea() {
		return area;
	}
	public void setArea(int area) {
		this.area = area;
	}
	public int getCount() {
		return count;
	}
	public void setCount(int count) {
		this.count = count;
	}
	public byte[] getData() {
		return data;
	}
	public void setData(byte[] data) {
		this.data = data;
	}
}

package {
	import flash.utils.ByteArray;

	[RemoteClass(alias="com.jidolstar.person.domain.PersonArea")]
	public class PersonArea	{
		public var area:int;
		public var count:int;
		public var data:ByteArray;
	}
}

package {
	public class AreaDetail {
		public var area:int;
		public var id:int;
		public var name:String;
		public var age:int;
	}
}

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600" 
			   xmlns:halo="library://ns.adobe.com/flex/halo">
	<fx:Declarations>
		<s:RemoteObject id="ro" destination="personRO">
			<s:method name="getPersonArea" result="result_handler(event)" fault="mx.controls.Alert.show(event.fault.faultString)"/> 
		</s:RemoteObject>
		<s:ArrayCollection id="ac"/>
	</fx:Declarations>
	<fx:Script>
		<![CDATA[
			import mx.collections.ArrayCollection;
			import mx.controls.Alert;
			import mx.rpc.events.ResultEvent;
			
			private function result_handler($event:ResultEvent):void {
				var personArea:PersonArea = $event.result as PersonArea;
				var count:int = personArea.count;
				var person:PersonDetail;
				var data:ByteArray = personArea.data;
				var area:int = personArea.area;
				ac.removeAll();
				data.endian = Endian.LITTLE_ENDIAN; //구조체로 저장된 데이터가 little endian인 경우 이 설정을 해야한다.//http://blog.naver.com/kimsumin75/20055881438
				ac.disableAutoUpdate();
				while( count-- ) {
					person = new PersonDetail;
					person.area = area;
					person.id = data.readShort()
					person.name = data.readUTFBytes(15,"utf-8");
					person.age = data.readShort();
					//trace(data.readByte()); //만약 c에서 #progma pack(1)을 사용하지 않았다면 19가 아닌 20바이트가 넘어올 것이므로 1바이트가 비게 된다. 이때는 이 부분의 주석이 풀어져야 제대로 읽어올 수 있다.
					ac.addItem(person);
				}
				ac.enableAutoUpdate();
				ac.refresh();
			}

			protected function button1_clickHandler(event:MouseEvent):void
			{
				ro.getPersonArea(parseInt(tiArea.text));
			}

		]]>
	</fx:Script>
	<halo:Form x="10" y="7" width="225" height="132">
		<halo:FormItem label="area">
			<s:TextInput id="tiArea" text="1"/>
		</halo:FormItem>
		<s:Button label="불러오기" click="button1_clickHandler(event)"/>
	</halo:Form>
	<halo:DataGrid x="243" y="10" height="360" width="385" dataProvider="{ac}">
		<halo:columns>
			<halo:DataGridColumn headerText="AREA" dataField="area"/>
			<halo:DataGridColumn headerText="ID" dataField="id"/>
			<halo:DataGridColumn headerText="NAME" dataField="name"/>
			<halo:DataGridColumn headerText="AGE" dataField="age"/>
		</halo:columns>
	</halo:DataGrid>
</s:Application>

// Product.as
package samples.externalizable {

import flash.utils.IExternalizable;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;

[RemoteClass(alias="samples.externalizable.Product")]
public class Product implements IExternalizable {
    public function Product(name:String=null) {
        this.name = name;
    }

    public var id:int;
    public var name:String;
    public var properties:Object;
    public var price:Number;

    public function readExternal(input:IDataInput):void {
        name = input.readObject() as String;
        properties = input.readObject();
        price = input.readFloat();
    }

    public function writeExternal(output:IDataOutput):void {
        output.writeObject(name);
        output.writeObject(properties);
        output.writeFloat(price);
    }
}
}

// Product.java
package samples.externalizable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Map;

/**
* This Externalizable class requires that clients sending and 
* receiving instances of this type adhere to the data format
* required for serialization.
*/
public class Product implements Externalizable {
    private String inventoryId;
    public String name;
    public Map properties;
    public float price;

    public Product()
    {
    }

        /**
        * Local identity used to track third party inventory. This property is
        * not sent to the client because it is server-specific.
        * The identity must start with an 'X'.
        */
        public String getInventoryId() {
            return inventoryId;
        }

        public void setInventoryId(String inventoryId) {
            if (inventoryId != null && inventoryId.startsWith("X"))
            {
                this.inventoryId = inventoryId;
            }
            else
            {
                throw new IllegalArgumentException("3rd party product
                inventory identities must start with 'X'");
            }
        }

        /**
         * Deserializes the client state of an instance of ThirdPartyProxy
         * by reading in String for the name, a Map of properties
         * for the description, and 
         * a floating point integer (single precision) for the price. 
         */
        public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
            // Read in the server properties from the client representation.
            name = (String)in.readObject();
            properties = (Map)in.readObject();
            price = in.readFloat();
            setInventoryId(lookupInventoryId(name, price));
        }
        /**
         * Serializes the server state of an instance of ThirdPartyProxy
         * by sending a String for the name, a Map of properties
         * String for the description, and a floating point
         * integer (single precision) for the price. Notice that the inventory 
         * identifier is not sent to external clients.
         */
        public void writeExternal(ObjectOutput out) throws IOException {
            // Write out the client properties from the server representation
            out.writeObject(name);
            out.writeObject(properties);
            out.writeFloat(price);
        }
        
        private static String lookupInventoryId(String name, float price) {
            String inventoryId = "X" + name + Math.rint(price);
            return inventoryId;
        }
}

class Example implements IExternalizable {
  
      public var one:Boolean;
      public var two:Boolean;
      public var three:Boolean;
      public var four:Boolean;
      public var five:Boolean;
      public var six:Boolean;
      public var seven:Boolean;
      public var eight:Boolean;
       public function writeExternal(output:IDataOutput) {
           var flag:int = 0;
           if (one) flag |= 1;
          if (two) flag |= 2;
          if (three) flag |= 4;
          if (four) flag |= 8;
          if (five) flag |= 16;
          if (six) flag |= 32;
          if (seven) flag |= 64;
          if (eight) flag |= 128;
           output.writeByte(flag);
      }
       public function readExternal(input:IDataInput) {
           var flag:int = input.readByte();
           one = (flag & 1) != 0;
          two = (flag & 2) != 0;
          three = (flag & 4) != 0;
          four = (flag & 8) != 0;
          five = (flag & 16) != 0;
          six = (flag & 32) != 0;
          seven = (flag & 64) != 0;
          eight = (flag & 128) != 0;
      }
 }

이 글은 ActionScript 3.0 프로젝트에서 BlazeDS와 통신하는 환경을 배경으로 한다.  Flex MXML를 배제하고 단지 Flex에 제공되는 RPC, 리모팅 관련 클래스를 사용하고자 한다. Flex MXML를 배제하는 이유는 다음과 같다.

Flex SDK의 Visual 컴포넌트들은 일반 솔루션 제품을 개발하는데 매우 유용하지만 어떤 경우에는 프로그램의 용량과 퍼포먼스 향상에는 도움이 안될 수 있다. 가령, Flex SDK에서 제공하는 Button과 List만 사용한다고 가정하자. 이 컴포넌트만 사용하는데도 불구하고 Flex 컴파일러는 그와 관련된 클래스까지 함께 컴파일해서 프로그램 용량을 크게 한다. 또한 Visual 컴포넌트들은 커다란 프레임워크로 만들어져 있기 때문에 Sprite만을 이용해서 만든 프로그램보다 퍼포먼스가 떨어진다.

물론 Flex에서 제공하는 컴포넌트를 적극적으로 다양하게 사용할 필요가 있다면 개발 효율성 및 유지보수 측면에서 Flex 프로젝트로 개발해야한다. 하지만 겨우 컴포넌트 몇개만 가져다가 사용하는 경우에는 Flex로 개발하는 것이 오히려 프로그램의 질을 떨어뜨릴 수 있는 결과를 초래할 수 있게 된다.(Flex가 나쁘다는 것이 아니라 필요에 맞게 사용해야한다는 것을 언급하는 것임을 강조한다.)  

Flex 환경에서 AMF3 통신

다음 예를 보자.

아래처럼 Flex 프로젝트로 만들어 Release 버전으로 컴파일 하게 되면 262kb가 나온다. 매우 단순한 프로그램인데도 불구하고 용량이 꽤 크다. 이유는 앞서 설명했다.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
	<mx:RemoteObject id="ro" destination="my-dest" showBusyCursor="true">
		<mx:method
			name="getData"
			result="returnHandler(event)"
			fault="mx.controls.Alert.show(event.fault.faultString)"/>
	</mx:RemoteObject>
	<mx:Button name="load" click="load()"/>
	 <mx:Script>
	<![CDATA[
		import mx.rpc.events.ResultEvent;

		private function returnHandler(e:ResultEvent):void
		{
			trace( e.result );
		}

		private function load():void
		{
			ro.getData( 1, 2 );
		}
	]]>
	</mx:Script>
</mx:Application>

AMF3 직렬화 처리가 안된 ActionScript 3.0 프로젝트 개발

AMF3 통신만 원한다면 앞서 설명한 이유 때문에 굳이 Flex로 개발할 필요가 없다. ActionScript 3.0 프로젝트 환경에서도 충분히 AMF 통신이 가능하기 때문이다. 아래는 OpenAMF나 PHPAMF와 같은 서버측 프로그램을 이용할 때 ActionScript 3.0 코드이다.

package {
	import flash.display.Sprite;
	import flash.net.NetConnection;
	import flash.net.ObjectEncoding;
	import flash.net.Responder;
	import flash.net.registerClassAlias;

	public class AS3NetConnectionTest extends Sprite
	{
		private var nc:NetConnection;

		public function AS3NetConnectionTest()
		{
			//create a netconnection
			nc = new NetConnection();
			nc.objectEncoding = ObjectEncoding.AMF3;
			nc.connect("http://192.168.*.*/_FLEX/amf");

			//create a responder
			var responder:Responder = new Responder(result, fault);

			//make the call
			nc.call("com.jidolstar.service.MyClass.getData", responder, 2);
		}

		private function result( data:Object ):void
		{
			trace("RPC Ok");
		}

		private function fault( event:Object ):void {
			 trace("RPC Fail");
			 trace(ObjectUtil.toString(event););
		}
	}
}

위 코드는 Flex에 관련된 것이 없고 단순히 flash.* 패키지 기반의 순수 ActionScript 3.0 환경에서 개발한 것이다. 용량도 Release로 컴파일하면 1kb도 안된다. Flex로 개발할때와 거의 250배 이상 용량차이를 보인다.

AMF3 직렬화 처리가 된 ActionScript 3.0 프로젝트 개발

하지만 BlazeDS, LCDS 서버의 리모트 객체와 클라이언트 객체간에 직렬화(serialization)가 필요한 경우 위 ActionScript 코드만으로는 해결할 수 없다. 이 문제는 본인의 경우 기존 프로젝트에서 BlazeDS로 만들어진 서버측의 코드를 변경하지 않고 Flex대신 ActionScript 3.0로 개발할때 문제가 발생했다. Flex Builder에서 ActionScript 3.0 프로젝트로 하면 playerglobal.swc, flex.swc, utilites.swc만 라이브러리로 등록되어 있기 때문에 BlazeDS에서 AMF3를 통해 넘겨주는 message관련 객체나 ArrayCollection 객체등을 직렬화 처리를 할 수 없게 된다. 왜냐하면 이들 3개 swc에는 이와 관련된 클래스가 정의되어 있지 않기 때문이다.

BlazeDS의 message관련 객체에 대한 직렬화를 위해서는 Flex SDK에 있는 rpc.swc가 필요하다. 또 ArrayCollection 직렬화를 위해서는 framework.swc 가 필요하다. 그럼 Flex를 사용하는 것과 무엇이 다르냐라고 반문할 수 있다.  그러나 ActionScript 3.0 기반이기 때문에 framework.swc에 정의된 비주얼 컴포넌트를 전부 사용하지 않고 단지 ArrayCollection과 그와 관련된 클래스만 사용하기 때문에 이것만으로도 프로그램의 용량을 획기적으로 줄이게 된다.

아래에서 설명하는 대로 프로젝트 환경을 구성해보자.

1. Flex Builder 3 Professional에서 ActionScript 3.0 프로젝트를 만든다.

2. 프로젝트에 Flex SDK에 있는 rpc.swc, rpc_rb.swc, framework.swc, framework_rb.swc를 라이브러리로 추가한다.

참고로, SWC는 윈도우의 경우 C:/Program Files/Adobe/Flex Builder 3/sdks/SDK버전/frameworks/에 libs 폴더와 locale 폴더에 있다. SWC에서 _rb라고 붙은 것은 resource bundle의 약어이다. Flex는 리소스 번들을 지원해주는데 우리의 목적과는 상관없는 것이지만 컴파일을 위해서는 추가해주어야 에러가 없이 컴파일이 된다.

3. 아래처럼 컴파일러 옵션에 -locale=en_US -include-resource-bundles=collections,rpc,messaging 를 추가한다.

4. 아래 코드처럼 코딩한다. (서버측 BlazeDS 설정은 여기서 설명을 생략한다.)

package {
	import com.jidolstar.vo.Class1;
	import com.jidolstar.vo.Class2;

	import flash.display.Sprite;
	import flash.net.registerClassAlias;

	import mx.collections.ArrayCollection;
	import mx.collections.ArrayList;
	import mx.core.mx_internal;
	import mx.logging.targets.TraceTarget;
	import mx.messaging.ChannelSet;
	import mx.messaging.channels.AMFChannel;
	import mx.messaging.config.ConfigMap;
	import mx.messaging.config.LoaderConfig;
	import mx.messaging.events.*;
	import mx.messaging.messages.*;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.remoting.RemoteObject;
	import mx.utils.ObjectProxy;

	use namespace mx_internal;

	/**
	 * RemoteObject 이용
	 */
	public class AS3RemoteObjectTest extends Sprite
	{
		public function AS3RemoteObjectTest()
		{

			registerClassAlias("flex.messaging.messages.CommandMessage",CommandMessage);
			registerClassAlias("flex.messaging.messages.RemotingMessage",RemotingMessage);
			registerClassAlias("flex.messaging.messages.AcknowledgeMessage", AcknowledgeMessage);
			registerClassAlias("flex.messaging.messages.ErrorMessage",ErrorMessage);
			registerClassAlias("flex.messaging.io.ArrayList", ArrayList);
			registerClassAlias("flex.messaging.config.ConfigMap",ConfigMap);
			registerClassAlias("flex.messaging.io.ArrayCollection",ArrayCollection);
			registerClassAlias("flex.messaging.io.ObjectProxy",ObjectProxy);
			registerClassAlias("flex.messaging.messages.HTTPMessage",HTTPRequestMessage);
			registerClassAlias("flex.messaging.messages.SOAPMessage",SOAPMessage);
			registerClassAlias("flex.messaging.messages.AsyncMessage",AsyncMessage);
			registerClassAlias("flex.messaging.messages.MessagePerformanceInfo", MessagePerformanceInfo);
			registerClassAlias("DSA", AsyncMessageExt);
			registerClassAlias("DSC", CommandMessageExt);
			registerClassAlias("DSK", AcknowledgeMessageExt);

			registerClassAlias("com.jidolstar.service.domain.Class1", Class1 );
			registerClassAlias("com.jidolstar.service.domain.Class2", Class2);

			//Sets up some more descriptive tracing on the client
			var target:TraceTarget = new TraceTarget();
			target.level = 0;

			//This is needed so the Flex libraries have access to the root objects properties
			var swfURL:String = this.loaderInfo.url;
			LoaderConfig.mx_internal::_url = this.loaderInfo.url;
			LoaderConfig.mx_internal::_parameters = this.loaderInfo.parameters;

			//This is the channel definition
			//This tells RemoteObject where to go
			var amfChannel:AMFChannel = new AMFChannel( "my-amf", "http://192.168.0.17/amf" );
			amfChannel.requestTimeout = 3;
			amfChannel.connectTimeout = 3;
			amfChannel.addEventListener(ChannelFaultEvent.FAULT, handleChannelFault);
			amfChannel.addEventListener(ChannelEvent.CONNECT, handleChannelConnect);
			amfChannel.addEventListener(ChannelEvent.DISCONNECT, handleChannelDisconnect);

			var channelSet:ChannelSet = new ChannelSet();
			channelSet.addChannel( amfChannel );

			//Make sure you include the right RemoteObject at
			//import mx.rpc.remoting.RemoteObject;
			//not
			//import  mx.rpc.remoting.mxml.RemoteObject;
			var ro:RemoteObject = new RemoteObject;
			ro.destination = "mydest";
			ro.channelSet = channelSet;
			ro.addEventListener(ResultEvent.RESULT, onResult );
			ro.addEventListener(FaultEvent.FAULT, onFault );
			ro.getData( 1, "jidolstar" );
		}

		public function onResult(event:ResultEvent):void
		{
			trace("RPC Ok");
			trace(event.result);

		}

		public function onFault(event:FaultEvent):void
		{
			trace("RPC Fail");
        	trace(event.message);
		}

		public function handleChannelFault(e:ChannelFaultEvent):void {
		    trace("Channel Fault");
			trace(e);
		}		

		public function handleChannelConnect(e:ChannelEvent):void {
		    trace("Channel Connect");
			trace(e);
		}

		public function handleChannelDisconnect(e:ChannelEvent):void {
		    trace("Channel Disconnect");
			trace(e);
		}

	}
}

위 코드는 BlazeDS나 LCDS 환경에서 RPC기반인 RemoteObject로 AMF3 통신처리를 하는 ActionScript 3.0 프로젝트 예제이다.

registerClassAlias()는 BlazeDS에서 오는 AMF3 메시지 객체를 ActionScript 3.0으로 직렬화처리를 위한 것이다. 이 함수에 message관련 클래스와 ArrayCollection이 등록되어 있는 것을 확인하기 바란다. 이것으로서 ActionScript 3.0 프로젝트를 통해서도 충분히 ArrayCollection을 쓸 수 있게 된다.

registerClassAlias("com.jidolstar.service.domain.Class1", Class1 )는 서버측에 정의된 com.jidolstar.service.domain.Class1 객체를 ActionScript 3.0에 정의된 com.jidolstar.vo.Class1으로 직렬화해준다. Flex에서는 com.jidolstar.vo.Class1이 만들어진 Class1.as파일의 Class명 위에 [RemoteClass(alias="com.jidolstar.service.domain.Class1")] 를 정의함으로서 registerClassAlias()에서 한 것과 동일하게 처리할 수 있지만 ActionScript 3.0환경에서 개발하므로 [RemoteClass]는 사용하기에 적합하지 못하다.

이 프로그램을 Release모드로 컴파일하면 89kb였다. Flex로 개발시에 262kb이였던 것에 비해서 분명 크게 줄었다. 이는 Flex 비주얼 컴포넌트에 관련된 것이 컴파일에서 제외되었기 때문이다. 하지만 순수하게 NetConnection으로만 만들었던 것이 1kb였다는 것을 감안한다면 여전히 크기가 크다. 위 코드에서는 RemoteObject를 이용했는데 NetConnection을 이용해보면 어떨까? 다음 코드를 보자.

package {
	import com.jidolstar.vo.Class1;
	import com.jidolstar.vo.Class2;

	import flash.display.Sprite;
	import flash.net.NetConnection;
	import flash.net.ObjectEncoding;
	import flash.net.Responder;
	import flash.net.registerClassAlias;

	import mx.collections.ArrayCollection;
	import mx.messaging.messages.*;

	/**
	 * NetConnection이용
	 */
	public class AS3NetConnectionTest extends Sprite
	{
		public function AS3NetConnectionTest()
		{
			registerClassAlias("flex.messaging.messages.RemotingMessage",RemotingMessage);
			registerClassAlias("flex.messaging.messages.AcknowledgeMessage", AcknowledgeMessage);
			registerClassAlias("flex.messaging.messages.ErrorMessage",ErrorMessage);
			registerClassAlias("flex.messaging.io.ArrayCollection",ArrayCollection);

			registerClassAlias("com.jidolstar.service.domain.Class1", Class1  );
			registerClassAlias("com.jidolstar.service.domain.Class2", Class2  );

			//create a netconnection
			var nc:NetConnection = new NetConnection();
			nc.objectEncoding = ObjectEncoding.AMF3;
			nc.connect("http://192.168.0.17/amf");

			//create the arguments that will be sent to the method
			var methodArguments:Array = [ 1, "jidolstar" ];

			//create a remoting message
			var remotingMessage:RemotingMessage = new RemotingMessage();
			remotingMessage.operation = "getData";
			remotingMessage.body = methodArguments;

			//The values of these 2 values come from the services-config.xml which is located in the ColfFusion server
			remotingMessage.destination = "mydest";
			remotingMessage.headers = {DSEndpoint: "my-amf"};

			//create a responder
			var responder:Responder = new Responder(result, fault);

			//make the call
			nc.call(null, responder, remotingMessage);
		}

		private function result(e:AcknowledgeMessage):void
		{
			trace("RPC Ok");
			trace(e.body);
		}

		private function fault(e:ErrorMessage):void {
			 trace("RPC Fail");
			 trace(e.faultString);
		}
	}
}

위 프로그램은 RemoteObject를 사용할 때와 동일하게 동작한다. 하지만 더 저레벨로 만들었기 때문에 프로그램 용량은 44kb로 RemoteObject를 사용할때보다 1/2로 줄었다. Flex로 개발할때와 비교할때 거의 6배 차이가 난다. 그러나 여전히 순수하게 NetConnection만으로 만들었을 때와 용량차이가 나는데 그것은 메시지 관련 클래스와 ArrayCollection을 컴파일할때 그와 연관된 클래스들이 포함되어 컴파일 되기 때문이다. 그 중에서는 우리의 목적인 AMF3 직렬화와는 상관없는 resource bundle에 관련된 것도 포함되어 있다. 필요하다면 resource bundle부분을 제외한 라이브러리를 만들어 내는 것도 하나의 방법이 될 수 있겠다. 일단 6배 이상 프로그램 용량을 줄일 수 있다는 것에 만족하려고 한다. 만약 이 부분에 대해서 더욱 가볍게 만드신 분이 있다면 함께 공유했으면 한다.(제가 그것까지 하기에는 시간이 ^^;;)

위 프로그램은 단순한 예제이므로 필요할 때 클래스화 시켜서 만드는 것이 좋을 것이라 생각한다.

관련글

• Remoting with BlazeDS from plain vanilla Actionscript 3 class
• Connecting Flash and Javascript via BlazeDS and DWR
• SWC 파일에 대해