【RemoteObject】 封装读取Web服务

//返回方法接口【IInvokeResponder】

package util.remote
{
 public interface IInvokeResponder
 {
  function addResultListener(handler:Function,...params):IInvokeResponder;
  
  function addFaultListener(handler:Function,...params):IInvokeResponder;
 }
}

//方法接口【IInvoker 】

package util.remote
{
 import flash.events.IEventDispatcher;
 
 public interface IInvoker extends IEventDispatcher
 {
  //使用args指定的参数调用名为method的方法

  function invoke(method:String,args:Array):IInvokeResponder;
 }
}

//具体实现【RemoteObjectInvoker 】

package util.remote
{
 import flash.events.EventDispatcher;
 
 import mx.rpc.AbstractOperation;
 import mx.rpc.AsyncToken;
 import mx.rpc.remoting.mxml.RemoteObject;
 
 public class RemoteObjectInvoker extends EventDispatcher implements IInvoker
 {
  private var ro:RemoteObject;
  public function RemoteObjectInvoker(dest:String)
  {
   ro=new RemoteObject(dest); 
  }
  
  public function invoke(method:String,args:Array):IInvokeResponder
  {
   var oper:AbstractOperation=ro.getOperation(method);
   var token:AsyncToken=oper.send.apply(oper,args);
   return new AsyncResponder(token);
  }
 }
}

//具体实现【AbstractResponder 】

package util.remote
{
 public class AbstractResponder implements IInvokeResponder
 {
  private var resultListeners:Array; 
  private var faultListeners:Array;
  
  public function AbstractResponder()
  {
  }
  
  public function addResultListener(handler:Function, ...params):IInvokeResponder
  {
   if(!resultListeners){
    resultListeners=new Array();
   }
   resultListeners.push(new Listener(handler,params));
   return this;
  }
  
  public function addFaultListener(handler:Function, ...params):IInvokeResponder
  {
   if(!faultListeners){
    faultListeners=new Array();
   }
   faultListeners.push(new Listener(handler,params));
   return this;
  }
  protected function notifyResultListeners(result:Object,first:int=0):void{
   if(resultListeners){
    for(var i:int=first;i<resultListeners.length;i++){
     var listener:Listener=resultListeners[i];
     var func:Function=listener.handler;
     var params:Array=listener.arguments;
     params.unshift(result);
     func.apply(null,params);
    }
   }
  }
  protected function notifyFaultListeners(fault:Object,first:int=0):void{
   if(faultListeners){
    for(var i:int=first;i<faultListeners.length;i++){
     var listener:Listener=faultListeners[i];
     var func:Function=listener.handler;
     var params:Array=listener.arguments;
     params.unshift(fault);
     func.apply(null,params);
    }
   }
  }
  protected function clear():void{
   resultListeners = [];
   faultListeners = [];
  }
 }
}
class Listener{
 private var _handler:Function;
 private var _args:Array;
 public function Listener(handler:Function,args:Array)
 {
  this._handler=handler;
  this._args=args?args:[];
 }
 
 public function get handler():Function{
  return _handler;
 }
 
 public function get arguments():Array{
  return _args.concat();
 }
}

//请求超时时间设置【SyncResponder 】

package util.remote
{
 public class SyncResponder extends AbstractResponder
 {
  private var _delay:Number;
  
  public function SyncResponder(delay:Number=1)
  {
   super();
   if(delay<1)
     throw new Error("invalid number for delay");
   this._delay = delay;
  }
  
  public function invokeResult(data:Object):void{   
   setTimeout(super.notifyResultListeners,1,data);
  }
  
  public function invokeFault(info:Object):void{   
   setTimeout(super.notifyFaultListeners,1,info);
  }
 }
}

//返回对象方法设置【AsyncResponder 】

package util.remote
{
 import mx.rpc.AsyncToken;

 public class AsyncResponder extends AbstractResponder
 {
  private var token:AsyncToken;
  
  public function AsyncResponder(token:AsyncToken)
  {
   super();
   this.token = token;
   token.addResponder(new mx.rpc.AsyncResponder(resultHandler,faultHandler));
  }
  
  private function resultHandler(data:Object, token:Object = null):void{
   super.notifyResultListeners(data);
  }
  
  private function faultHandler(info:Object, token:Object = null):void{
   super.notifyFaultListeners(info);
  }
 }
}

//对外服务接口【IBaseService】

package util.remote
{
 public interface IBaseService
 {
  function init(_dest:String,_invoker:String):void;
  function invoke(method:String,...args):IInvokeResponder;
 }
}

//对外服务实现【BaseService】

package util.remote
{
 public class BaseService
 {
  private var _dest:String;
  private var _invoker:IInvoker;
  public function BaseService(dest:String)
  {
   this._dest=dest;
  }
  
  protected function get destination():String{
   return _dest;
  }
  protected function get invoker():IInvoker{
   if(!_invoker){
    _invoker=new RemoteObjectInvoker(destination);
   }
   return _invoker;
  }
  
  protected function set invoker(value:IInvoker):void{
   this._invoker=value;
  }
  
  protected function invoke(method:String,...args):IInvokeResponder{
   return invoker.invoke(method,args);
  }
 }
}

-------------------------------------------------------------------------------------------

接口定义完毕，实现与调用方法如下

//上传类【FileLoadService 】

package model.service
{
 import flash.utils.ByteArray;
 
 import util.remote.BaseService;
 import util.remote.IInvokeResponder;
 
 public class FileLoadService extends BaseService
 {
  public function FileLoadService()
  {
   super("uploadService");//传Id
  }
  /**
   * 上传文件
   * @param content 文件内容
   *        name    文件名称
   * */
  public function uploadFile(content:ByteArray,name:String):IInvokeResponder
  {
      return super.invoke("uploadFile",content,name);//方法名称 和方法参数
  }

}

调用方法

var fileService:FileLoadService = new FileLoadService();
   fileService.uploadFile(file.data,file.name)//file为文件流对象
    .addResultListener(onSuccess)//返回结果方法
    .addFaultListener(onFault);//返回失败方法

-----------------------------------------------------------------------

java中对应的方法

 /**
  * 文件上传
  * 
  * @param content，文件内容
  * @param fileName，文件名称
  * @param fileType，文件类型
  */
 public void uploadFile(byte[] content,String fileName) 
 {
  File file = new File(fileName);
  try {
   FileOutputStream stream = new FileOutputStream(filePath+file);//filePath为服务器资源路径
   stream.write(content);
   stream.close();
  } catch (Exception e) {
   logger.error(e);
  }
 }