flex upload download avec blazeds

Version imprimable

Bonjour,
j'ai trouvé sur un blog, un projet flex pour upload et download avec java via blazeds mais j'arrive pas à le faire tourner.
voici les codes :
FileUtils.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;
 
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.flex.remoting.RemotingInclude;
import org.springframework.stereotype.Service;
 
@Service
@RemotingDestination
public class FileUtils {
 
	@RemotingInclude
	public String doUpload(byte[] bytes, String fileName) throws Exception {
		// fileName = System.getProperty("java.io.tmpdir") + "/" + fileName;
		fileName = "c:/myfile/" + fileName;
		System.out.println(fileName);
		File f = new File(fileName);
		FileOutputStream fos = new FileOutputStream(f);
		fos.write(bytes);
		fos.close();
		return "success";
	}
 
	@RemotingInclude
	public List getDownloadList() {
		// File dir = new File(System.getProperty("java.io.tmpdir"));
		File dir = new File("c:/myfile/");
		String[] children = dir.list();
		List dirList = new ArrayList();
		if (children == null) {
			// Either dir does not exist or is not a directory
		} else {
			for (int i = 0; i < children.length; i++) {
				// Get filename of file or directory
				dirList.add(children[i]);
			}
		}
		return dirList;
	}
 
	@RemotingInclude
	public byte[] doDownload(String fileName) {
		FileInputStream fis;
		byte[] data = null;
		FileChannel fc;
 
		try {
			/*fis = new FileInputStream(System.getProperty("java.io.tmpdir")
					+ "/" + fileName);*/
			fis = new FileInputStream("c:/myfile/" + fileName);
			fc = fis.getChannel();
			data = new byte[(int) (fc.size())];
			ByteBuffer bb = ByteBuffer.wrap(data);
			fc.read(bb);
		} catch (FileNotFoundException e) {
			// TODO
		} catch (IOException e) {
			// TODO
		}
		return data;
	}
}

Download.mxml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
<?xml version="1.0" encoding="utf-8"?>
<mx:Panel xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" 
	width="100%" height="100%" title="Download Files">
 
	<mx:Script>
		<![CDATA[
			import mx.collections.ArrayCollection;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			import mx.rpc.AsyncToken;
 
			private var UploadFiles:Array = new Array();
			private var UploadFilesColl:ArrayCollection = new ArrayCollection();
			private var fileData:ByteArray = new ByteArray();
			private var fileName:String;
 
 
	  		private function uploadResultHandler(event:ResultEvent):void
	  		{
	  		  if ( event.token.kind == "remoteFileList") {	
	              UploadFilesColl = event.result as ArrayCollection;
	              for ( var i:int = 0 ; i <  UploadFilesColl.length ; i++ ) {
	                UploadFiles.push({  name:UploadFilesColl[i]
	                                 ,  status:"initial"});
	              }
	              listFiles.dataProvider = UploadFiles;
              } else  {
              	  fileData = event.result as ByteArray;
              	  fileName = event.token.kind;
              	  for ( var b:int = 0 ; b <  UploadFiles.length ; b++ ) {
                  if( UploadFiles[b].name == event.token.kind ) {
                  	UploadFiles[b].status = "Ready";
	   				listFiles.dataProvider  = UploadFiles;
                  	break;
                  }
                }
 
              }
	  		}
 
	  		private function faultResultHandler(event:FaultEvent):void
	  		{
	  		}
 
	  		private function saveFile(event:Event):void
	  		{
 	  			var fileReference:FileReference = new FileReference();
 	  			fileReference.save(fileData,fileName);
	  		}
 
	  		private function getRemoteFiles(event:Event):void
	  		{
   				var token:AsyncToken = AsyncToken(remoteDownload.getDownloadList());
           		token.kind = "remoteFileList";
	  		}
 
	  		private function getDownload(event:Event):void
	  		{
   				var token:AsyncToken = AsyncToken(
   				    remoteDownload.doDownload(listFiles.selectedItem.name));
           		token.kind = listFiles.selectedItem.name;
	  		}
		]]>
	</mx:Script>
 
 
	<mx:RemoteObject id="remoteDownload" destination="FileUtils" 
		result="uploadResultHandler(event)"
		fault="faultResultHandler(event)">
 
		<mx:channelSet>
			<mx:ChannelSet>
				<mx:AMFChannel uri="http://localhost:8080/messagebroker/amf"/>
			</mx:ChannelSet>
		</mx:channelSet>
 
	</mx:RemoteObject>
 
 
	<mx:Canvas width="100%" height="100%">
		<mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
			verticalScrollPolicy="on"
			draggableColumns="false" resizableColumns="false" sortableColumns="false">
			<mx:columns>
				<mx:DataGridColumn headerText="File" width="150" dataField="name" wordWrap="true"/>
				<mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
			</mx:columns>
 
		</mx:DataGrid>
	</mx:Canvas>
	<mx:ControlBar horizontalAlign="center" verticalAlign="middle">
		<mx:Button id="btnList" toolTip="List remote files" 
			width="150" 
			label="Get Remote Files"
			click="getRemoteFiles(event)"/>
		<mx:Button id="btnRetrieve" toolTip="Retrieve file" 
			 width="150" click="getDownload(event)" label="Retrieve File"/>
		<mx:Button id="btnSave" toolTip="Save file" 
			 width="150" click="saveFile(event)" label="Save File"/>
	</mx:ControlBar>
 
</mx:Panel>

Upload.mxml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
<?xml version="1.0" encoding="utf-8"?>
<mx:Panel xmlns:mx="http://www.adobe.com/2006/mxml" 
	layout="vertical" width="100%"  height="100%"
	title="Upload Files">
 
 
	<mx:Script>
		<![CDATA[
			import mx.rpc.AsyncToken;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
 
			private var refUploadFile:FileReference;
 
			private var UploadFiles:Array = new Array();
 
 
			// Called to add file(s) for upload
			private function addFiles():void {
				refUploadFile = new  FileReference();
	  			refUploadFile.browse();
	  			refUploadFile.addEventListener(Event.SELECT,onFileSelect);
	  			refUploadFile.addEventListener(Event.COMPLETE,onFileComplete);
			}
 
			// Called when a file is selected
			private function onFileSelect(event:Event):void {
				UploadFiles.push({  name:refUploadFile.name,
									size:formatFileSize(refUploadFile.size),
									status:"initial"});
				listFiles.dataProvider  = UploadFiles;
				listFiles.selectedIndex = UploadFiles.length - 1;
 
                refUploadFile.load();
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == refUploadFile ) {
                  	UploadFiles[i].status = "loaded";
	   				listFiles.dataProvider  = UploadFiles;
                  	break;
                  }
                }
			}
 
			// Called to format number to file size
			private function formatFileSize(numSize:Number):String {
				var strReturn:String;
				numSize = Number(numSize / 1000);
				strReturn = String(numSize.toFixed(1) + " KB");
				if (numSize > 1000) {
					numSize = numSize / 1000;
					strReturn = String(numSize.toFixed(1) + " MB");
					if (numSize > 1000) {
						numSize = numSize / 1000;
						strReturn = String(numSize.toFixed(1) + " GB");
					}
				}				
				return strReturn;
			}
 
 
 
	  		private function onFileComplete(event:Event):void
	  		{
				refUploadFile = event.currentTarget as FileReference;
				var data:ByteArray = new ByteArray();
				refUploadFile.data.readBytes(data,0,refUploadFile.data.length);
 
   				var token:AsyncToken = AsyncToken(
   				                          remoteUpload.doUpload(data, refUploadFile.name)
   				                          );
 
           		token.kind = refUploadFile.name;
 
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == refUploadFile ) {
                  	UploadFiles[i].status = "upload";
	   				listFiles.dataProvider  = UploadFiles;
                  	break;
                  }
                }
	  		}
 
	  		private function uploadResultHandler(event:ResultEvent):void
	  		{
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == event.token.kind ) {
                  	UploadFiles[i].status = "finished";
	   				listFiles.dataProvider  = UploadFiles;
                  	break;
                  }
                }
	  		}
 
	  		private function faultResultHandler(event:FaultEvent):void
	  		{
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == event.token.kind ) {
                  	UploadFiles[i].status = "error";
	   				listFiles.dataProvider  = UploadFiles;
                  	break;
                  }
                }
	  		}
 
 
		]]>
	</mx:Script>
 
	<mx:RemoteObject id="remoteUpload" destination="FileUtils" 
		result="uploadResultHandler(event)"
		fault="faultResultHandler(event)">
 
		<mx:channelSet>
			<mx:ChannelSet>
				<mx:AMFChannel uri="http://localhost:8080/messagebroker/amf"/>
			</mx:ChannelSet>
		</mx:channelSet>
 
	</mx:RemoteObject>
 
 
	<mx:Canvas width="100%" height="100%">
		<mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
			allowMultipleSelection="true" verticalScrollPolicy="on" 
			draggableColumns="false" resizableColumns="false" sortableColumns="false">
			<mx:columns>
				<mx:DataGridColumn headerText="Files" width="150" dataField="name" wordWrap="true"/>
				<mx:DataGridColumn headerText="Size" width="50" dataField="size" textAlign="right"/>
				<mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
			</mx:columns>
		</mx:DataGrid>
	</mx:Canvas>
	<mx:ControlBar horizontalAlign="center" verticalAlign="middle">
		<mx:Button id="btnAdd" toolTip="Add file(s)" click="addFiles()" 
			label="Upload Files" width="150"/>
	</mx:ControlBar>
 
 
</mx:Panel>

et enfin flexUploadDownload.mxml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
	xmlns:com="components.*" creationComplete="init()">
 
 
	<mx:Canvas width="500" height="450" horizontalCenter="0" verticalCenter="0">
	  <mx:VBox>
		<com:Upload   width="500" height="200"/>
		<com:Download width="500" height="200"/>
	  </mx:VBox>
	</mx:Canvas>
 
 
</mx:Application>

s'agit-il d'un problème de configuration sachant que j'utilise Flash Builder4 (flex sdk4) et flash player 10.0.0 ?
merci de me porter conseil.

27/04/2010, 06h20
ellene

Bonjour,

Tu dis que ça ne fonctionne pas mais as tu une erreur particulière ? Le service n'est pas appelé ? As tu une belle stackTrace côté Java ?

bonjour,
coté java et avec blazeds j'arrive à trouver mes méthodes dans flex:
- doUpload
- doDowload
- getDownloadList
et avec le bouton "test" proposée avec flash builder 4 j'arrive à tester mes méthodes et ça marche parfaitement.

mais coté flex c'est supposé appeler ces méthodes distantes alors que ça se passe rien comme si s'était une simple interface sans appel à ces fonctions.

si vous voulez je pourrais ajouter le fichier AS généré lors de la création de mon service, peut être que le problème arrive de ce fichier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
/**
 * This is a generated class and is not intended for modfication.  To customize behavior
 * of this service wrapper you may modify the generated sub-class of this class - FileUtils.as.
 */
package services
{
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.services.wrapper.RemoteObjectServiceWrapper;
import com.adobe.serializers.utility.TypeUtility;
import flash.utils.ByteArray;
import mx.rpc.AbstractOperation;
import mx.rpc.AsyncToken;
import mx.rpc.remoting.Operation;
import mx.rpc.remoting.RemoteObject;
 
import mx.collections.ItemResponder;
import com.adobe.fiber.valueobjects.AvailablePropertyIterator;
 
[ExcludeClass]
internal class _Super_FileUtils extends com.adobe.fiber.services.wrapper.RemoteObjectServiceWrapper
{      
 
    // Constructor
    public function _Super_FileUtils()
    {
        // initialize service control
        _serviceControl = new mx.rpc.remoting.RemoteObject();
 
        var operations:Object = new Object();
        var operation:mx.rpc.remoting.Operation;
 
        operation = new mx.rpc.remoting.Operation(null, "doUpload");
		 operation.resultType = String; 		 
        operations["doUpload"] = operation;
 
        operation = new mx.rpc.remoting.Operation(null, "doDownload");
		 operation.resultType = ByteArray; 		 
        operations["doDownload"] = operation;
 
        operation = new mx.rpc.remoting.Operation(null, "getDownloadList");
		 operation.resultElementType = Object;
        operations["getDownloadList"] = operation;
 
 
        _serviceControl.operations = operations;   
		_serviceControl.convertResultHandler = com.adobe.serializers.utility.TypeUtility.convertResultHandler;
		destination = "fileUtils";
 
 
 
         model_internal::initialize();
    }
 
	/**
	  * This method is a generated wrapper used to call the 'doUpload' operation. It returns an mx.rpc.AsyncToken whose 
	  * result property will be populated with the result of the operation when the server response is received. 
	  * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
	  * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
	  */          
	public function doUpload(arg0:ByteArray, arg1:String) : mx.rpc.AsyncToken
	{
		var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("doUpload");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(arg0,arg1) ;
 
		return _internal_token;
	}   
 
	/**
	  * This method is a generated wrapper used to call the 'doDownload' operation. It returns an mx.rpc.AsyncToken whose 
	  * result property will be populated with the result of the operation when the server response is received. 
	  * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
	  * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
	  */          
	public function doDownload(arg0:String) : mx.rpc.AsyncToken
	{
		var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("doDownload");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(arg0) ;
 
		return _internal_token;
	}   
 
	/**
	  * This method is a generated wrapper used to call the 'getDownloadList' operation. It returns an mx.rpc.AsyncToken whose 
	  * result property will be populated with the result of the operation when the server response is received. 
	  * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
	  * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
	  */          
	public function getDownloadList() : mx.rpc.AsyncToken
	{
		var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getDownloadList");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
 
		return _internal_token;
	}   
 
}
 
}

voilà merci

11/05/2010, 11h03
smh_master
en faite j'ai trouvé la solution pour ceux qui leur intéresse. Il fallait juste faire coté java :
Code:

1 2 @Service("FileUtils") @RemotingDestination(channels = {"my-amf"})
au lieu de :
Code:

1 2 @Service @RemotingDestination