Etudes des API Java pour la génération de code Flash

IPST-CNAM
39, allées Jules Guesde
BP 61517
31015 Toulouse cedex 6
FRANCE
CONSERVATOIRE NATIONAL DES ARTS ET METIERS
CENTRE REGIONAL DE TOULOUSE
RAPPORT
présenté en vue d’obtenir
L’EXAMEN PROBATOIRE
DU DIPLOME D’INGENIEUR CNAM
en
INFORMATIQUE
OPTION SYSTEMES D’INFORMATION
par
Patrick DUBERNET
Etudes des API Java
pour la génération de code Flash
Date de la soutenance :
Mardi 15 Mai 2007
Membres du jury :
Président :
Examinateur :
Examinateur :
Professeur Pollet
Professeur Hadj Batatia
Professeur Christophe Piombo
Remerciements
Je tiens à remercier Messieurs Eric-Marc MAHE et Alain BARBIER du service
Clients Solutions de la société Sun Microsystems, pour avoir donné des
informations concernant le produit Java/J2EE, répondu à plusieurs de mes
questions et m’avoir soutenu durant mes recherches.
Merci à Monsieur Stuart MacKay de la société Flagstone Software Ltd, qui
m’a présenté son framework Transform SWFTM pour mieux comprendre
l’intérêt des API Java pour la génération de code Flash.
Merci à Monsieur Sébastien FRAYSSE Directeur des Technologies de
l’Innovation de la société i3M, pour avoir répondu à plusieurs de mes
questions concernant la technologie Flash.
Merci à Madame Dominique BUREAU des Editions O’Reilly®, pour m’avoir
renseigné sur les documents concernant les API Java.
Merci aux enseignants Messieurs Hadj BATATIA, Xavier CREGUT, Pierre
GAMBAROTTO et Romulus GRIGORAS du Centre Régional du CNAM
Toulouse pour l’éclairage professionnel qu’ils ont su m’apporter durant mes
études et mes recherches.
Merci à Thierry DUBERNET et son épouse Marie, qui suivent mon travail et
m’encouragent depuis plus de cinq ans.
Enfin, je n’oublie pas mes amis (tout particulièrement Ionut MIHALCEA,
Davide TORTORA, Mathieu HOLDERBAUM, Thierry CARRERE, Véronique
DUMOUTIER et Olivier GESTA), ainsi que ma famille, pour le soutien
inconditionnel dont ils ont fait preuve.
Table des Matières
INTRODUCTION.............................................................................................................................1
ADOBE MACROMEDIA FLASHTM...............................................................................................2
I.
1.
2.
3.
L’EDI ADOBE MACROMEDIA FLASHTM ........................................................................................ 3
LES LANGAGES FLASH ET ACTIONSCRIPT : ................................................................................... 5
LES FORMATS SHOCKWAVE FLASH (.SWF) .................................................................................. 6
a)
Les formats d’édition........................................................................................................ 6
b)
Le format de publication ................................................................................................... 6
c)
Le mode autonome .......................................................................................................... 6
II.
1.
ARCHITECTURE TROIS TIERS/WEB DYNAMIQUE ...............................................................7
UN PEU D’HISTOIRE – ARCHITECTURE « N » TIERS ........................................................................ 8
L’architecture trois tiers.................................................................................................... 8
En faveur de Java/J2EE .................................................................................................... 9
2.
LE MODELE MVC STANDARD ................................................................................................... 10
a)
Les étapes de fonctionnement ......................................................................................... 11
b)
Les composants/conteneurs ............................................................................................ 12
i.
Les servlets .............................................................................................................. 12
ii.
Les pages JSP ........................................................................................................... 13
iii. Les Beans ................................................................................................................. 14
3.
L’INTEROPERABILITE ........................................................................................................... 15
4.
FLASH ET LES APPLICATIONS DISTRIBUEES ................................................................................. 16
5.
TECHNOLOGIES NECESSAIRES ................................................................................................. 18
III.
1.
2.
3.
4.
IV.
a)
b)
INTERFACE GRAPHIQUE (API/FRAMEWORK) ...................................................................19
OPPORTUNITES DE L’UTILISATION DE JAVA ................................................................................ 19
LES API JAVA (ORIENTEES PERSONNALISATION SWF) ................................................................. 19
LES API JAVA EVOLUEES (ORIENTEES RIA) ............................................................................... 20
LA CREATION DE CONTENUS « RICHES » ................................................................................... 20
API JAVA POUR GENERER DU CODE FLASH ......................................................................21
LA SOLUTION ADOBE MACROMEDIA FLEXTM ................................................................................ 21
LA SOLUTION OPENLASZLOTM ................................................................................................. 22
LES API DE FLAGSTONE TRANSFORM SWFTM ............................................................................. 22
ARCHITECTURE DE NOUVELLE GENERATION ................................................................................. 23
LA COMMUNICATION ENTRE FLASH ET UN SERVEUR D’APPLICATION JAVA ............................................ 24
a)
Interaction entre une animation Flash et une base de données............................................. 24
b)
Architecture et mécanisme interne du serveur de présentation ............................................. 27
c)
Côté client (Flash PlayerTM) ............................................................................................. 28
6.
LA POSITION DE SUN MICROSYSTEMS® SUR LES API FLASH ........................................................... 31
1.
2.
3.
4.
5.
V.
LES AUTRES DOMAINES D’APPLICATIONS DES API JAVA ....................................................32
1.
2.
3.
ACCES AUX DONNEES EN UTILISANT LES SERVICES WEB ................................................................. 32
ACCES AUX DONNEES EN UTILISANT LE RPC JAVA ........................................................................ 33
L’OUVERTURE VERS DE NOUVEAUX SERVICES ............................................................................... 33
CONCLUSION...............................................................................................................................34
ANNEXES .....................................................................................................................................34
ANNEXES .....................................................................................................................................35
TABLE DES ILLUSTRATIONS ........................................................................................................60
GLOSSAIRE ET ABBREVIATIONS .................................................................................................61
BIBLIOGRAPHIE ET REFERENCES ................................................................................................70
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Introduction
De nos jours, de nombreux supports sont capables de véhiculer des
informations en temps réel, de façon visuelle et ergonomique afin de toucher
un maximum de consommateurs, entreprises ou particuliers. Parmi les
périphériques à la pointe de la Technologie se détachent principalement les
téléphones portables de nouvelle génération (technologie 3G), les organiseurs
électroniques (BlackBerryTM, PalmTM, Pocket PCTM …), les consoles mobiles de
jeux (WiiTM, PlayStationTM …) ainsi qu’Internet. Ce dernier tout particulièrement
a révolutionné en quelques années le rapport de l’Homme au monde et au
temps, en apportant une mine d’informations, un gain de temps et de
productivité, et par conséquent des possibilités économiques colossales.
Ainsi, la recherche du profit maximum oriente de plus en plus les entreprises à
développer des applications Web réunissant facilité de développement, de
déploiement, d’utilisation, de maintenance et de mise à jour, tout en étant
ergonomiques (voire ludiques) et accessibles à une population universelle et
multiculturelle. Pour ce faire, Internet est devenu l’élément porteur d’une toute
nouvelle génération d’applications Internet évoluées dites applications
« riches » ou RIA (Rich Internet Applications). Bien qu’Internet reste assujetti
aux limitations des applications, interfaces,
supports physiques et
technologiques existants, nous verrons dans cette étude que ces nouvelles
applications Internet dites « riches » apportent l’information sous une forme de
plus en plus dynamique, interactive et proche des applications « lourdes »
telles que les applications bureautiques installées en local sur les ordinateurs.
Parmi les outils permettant la création de telles applications, Adobe®
Macromedia FlashTM est sûrement l’un des plus évolués du marché. L’intérêt de
Flash est qu’il offre une possibilité graphique proche des applications lourdes
(tout en étant simple d’utilisation côté clients). Flash PlayerTM lit des fichiers
Flash SWF. Java J2EETM et les interfaces pour l’accès programmé aux API
(Application Programming Interface) qui permettent la génération de code
Flash, proposent soit de personnaliser (« customiser »), soit de générer
complètement ces fichiers Flash. En couplant ces deux technologies dans une
architecture de type trois tiers, nous avons les prémices de ce qui permettra
de réaliser des RIA.
Aujourd’hui, plus de 98% des ordinateurs clients connectés à Internet ont un
lecteur de fichiers SWF (Flash PlayerTM) et 86% JVM (Java Virtual MachnieTM)
de JAVA Sun Microsystems® (statistiques réalisées par Millward Brown,
décembre 2006). Tout d’abord, une présentation de Flash et du langage de
programmation ActionScript (AS) sera faite pour mieux comprendre le format
de fichiers SWF. On examinera ensuite une architecture trois tiers type sur
laquelle les RIA s’appuient. Nous apporterons une première réflexion sur
l’intérêt de Flash dans une telle architecture. Dans un second temps, nous
aborderons la partie « front office » et interfaces graphiques offertes par Flash,
suivie de la partie « back office » (applications métiers/serveurs) avec le
concept JAVA et API. Nous terminerons par un résumé des scénarii et
aborderons les autres domaines d’applications possibles avant de conclure.
- Page 1/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
I. Adobe Macromedia FlashTM
Depuis plusieurs années, Internet héberge aussi bien des sites statiques
(vitrines familiales ou professionnelles) que des sites un peu plus
interactifs comme les magasins virtuels. Le format de fichiers standards
utilisés sur le web est le HTML (HyperText Markup Language). Le HTML
permet en particulier d'insérer des hyperliens dans du texte, donc de créer
de l'hypertexte, d'où le nom du langage. Un système hypertexte est un
système contenant des documents liés entre eux par des hyperliens
permettant de passer automatiquement (en pratique grâce à
l'informatique) du document consulté à un autre document lié. Les pages
HTML liées entre elles forment ce que l’on appelle un site Web. Un site
peut être agrémenté de texte, d’images, de sons et de vidéos afin de le
rendre un peu plus « dynamique » et attractif. Le côté interactif d’un site
ne tient quasiment qu’à la navigabilité entre les documents, navigabilité
obtenue grâce aux hyperliens.
Il y a environ une dizaine d’années, une société nommée à l’époque
Macromedia® sort un produit qui révolutionnera le Web : Macromedia
FlashTM. Sa différence fondamentale réside dans le fait qu’il offre un vrai
studio de montage multimédia orienté Web, point que nous développerons
un peu plus loin.
En fait, le navigateur Internet sous sa forme standard ne peut
« décrypter » et afficher le contenu d’une animation Flash. Macromedia®
met donc à disposition un plugin nommé Flash PlayerTM, à installer sur les
machines clientes. Mais le monde des ordinateurs professionnels (comme
familiaux) est composé de plusieurs types de machines car un ordinateur
peut utiliser un CPU (processeur) ou un OS (système d’exploitation)
différent ; il existe trois principaux OS sur le marché pour les ordinateurs
professionnels et personnels : Microsoft WindowsTM, LinuxTM (dérivé du
système d’exploitation UNIX du monde professionnel), et Mac OSTM pour
les ordinateurs Apple®.
Nous devons garder à l’esprit que Flash peut être non seulement présent
dans nos ordinateurs, mais aussi dans d’autres périphériques ou produits
dérivés comme par exemple la téléphonie, les consoles de jeux, etc…
- Page 2/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Figure 1 – Nouvelle génération d’applications
Afin de communiquer sous ces différentes plates-formes, Macromedia a
développé un lecteur de fichiers Flash, le Flash PlayerTM, pour chaque type
de système d’exploitation. Ce fichier Flash est le SWF (ShockWave Flash),
c’est un format de fichiers sous forme binaire (bytecode) qui sera donc
précompilé par Macromedia FlashTM ; le Flash PlayerTM s’occupera de finir le
travail côté client afin de faire fonctionner l’animation sous chacune des
plate-formes.
Examinons maintenant l’EDI Flash, l’histoire de son langage, une approche
du langage ActionScript et la description des différents formats de fichiers
utilisés au travers de Macromedia FlashTM.
1. L’EDI Adobe Macromedia FlashTM
Il faut savoir que Macromedia FlashTM est une application orientée
« web design » qui a su mettre à rude épreuve sa technologie. C’est avant
tout un logiciel qui permet de réaliser des animations vectorielles d’une
grande qualité. L’animation générée peut être agrémentée de différents
composants graphiques et multimédia. En fait, Flash peut « encapsuler »
dans ces animations des images vectorielles, des photos, des fichiers son
et même de la vidéo. Adobe Macromedia FlashTM se présente alors comme
un studio complet d’animation.
Il faut savoir que Macromedia FlashTM est aussi un vrai EDI (environnement
de développement intégré), c’est-à-dire un programme regroupant un
éditeur de texte, un compilateur, des outils automatiques de fabrication, et
souvent un débogueur.
- Page 3/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Timeline
Bibliothèque d’objets
(Movie Clip…)
Scène
EDI
Figure 2 – EDI Macromedia Flash
Ce produit permet d’ouvrir les portes de la créativité et seule l’imagination
de ses utilisateurs en définit les limites. Autrefois, seuls les designers de
sites Internet utilisaient cet outil pour réaliser des animations stimulant
l’ouïe et le regard des « cybernautes ». C’est principalement pour des
raisons marketing qu’il a été utilisé. On réalisait (et on réalise encore) des
minis encarts publicitaires, voire carrément des spots complets, qui
agrémentent ici et là les pages HTML.
Brièvement, nous pouvons dire que le designer possède une scène sur
laquelle il pourra mettre en place un décor et des composants ou
MovieClips. Ces composants sont tout simplement des objets (images
vectoriels, photos, sons, d’autres fichiers Flash) qui sont instanciés sur la
scène. Ce comportement est relativement proche du comportement de
la POO (programmation orientée objet) ; c’est une image, bien sûr, mais
ce n’est pas complètement inexact.
Il existait déjà à l’époque un langage qui était utilisé pour piloter les
animations soit de façon autonome à l’intérieur d’elles-mêmes, soit entre
elles, soit par le biais de composants que l’utilisateur pouvait utiliser
(exemple : bouton graphique que l’on clique, que l’on survole … mais aussi
- Page 4/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
avec des touches au clavier etc…). Un bon début pour l’interactivité.
Ce langage est le Flash Code. Il existait sous la version 4 de Flash mais
aussi sous la version 5. En fait, il est possible de mettre directement du
code dans chaque composant qui sera disposé sur la scène pour simuler
-par exemple - la collision de deux « MovieClips » qui pourraient être
représentés par un ballon et le sol- mais aussi dans la « Timeline » à une
image donnée qui permettrait de faire des déplacements dans le
déroulement de l’animation avec des sauts de séquences, des arrêts, des
retours en arrière…
Nous allons à présent étudier les changements et
technologiques dans le langage de Macromedia FlashTM.
les
avancées
2. Les langages Flash et ActionScript :
Récemment, la société Adobe® a racheté la société Macromedia® et
ses produits, déjà fortement implantés mondialement et leaders sur le
marché de la mise en forme de documents interactifs et dynamiques pour
le Web. Les versions telles que Macromedia FlashTM 4 et 5 étaient dotées
d’un langage plutôt procédural (qui ne renvoie pas de résultats). En
revanche, Macromedia FlashTM 5 était muni d’une première version d’AS
(ActionScriptTM 1.0) qui fut porté par la suite sur la version Flash MXTM.
Comme l’ancien langage, il est simplement destiné aux interactions telles
que les clics sur les boutons, et autres actions décrites en amont. C’est en
2004 que Macromedia FlashTM (aujourd’hui Adobe Macromedia Flash MXTM)
passe au langage propriétaire dorénavant nommé AS.
La version professionnelle comme les nouvelles versions d’Adobe
Macromedia FlashTM incluent AS 2.0 et aujourd’hui AS 3.0. Ces deux
versions possèdent la notion de classes et d’objets, d’héritages,
d’interfaces, de généralisation comme de spécialisation, et nous pouvons
alors parler d’un vrai langage de programmation orienté objet (POO). Il a
été développé pour des tâches plus complexes telles que la manipulation
des contenus et des données.
ActionScript 3.0 est un langage basé sur la norme ECMAScript version 3
(ECMA-262) depuis ActionScript 3.0. En fait, ActionScript 2.0 (et maintenant
3.0) sont proches du langage JavaScript et sont faiblement typés. Mais
bien que l’on puisse encore développer sans le typage des variables, il est
aussi possible de les typer fortement ce qui en facilite le débogage et une
réutilisation plus simple telle que l’on peut le voir dans des grands
langages orientés objet tel que Java. On conserve encore la version 2.0 car
pour cette étude, nous avons observé d’abord une API qui n’est pas encore
passée à la version 3.0 et l’API FlexTM d’Adobe® qui supporte cette
dernière. Ces API seront présentées plus en détail dans le chapitre IV.
La capacité de Flash de combiner du code procédural et du code orienté
objet dans un environnement de développement graphique, basé sur le
- Page 5/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
temps, le rend exceptionnellement souple. Cette souplesse est à la fois
puissante et dangereuse. D’un côté, les animations et les transitions
d’interfaces -qui sont triviales dans Flash- peuvent réclamer des heures de
codage personnalisé dans les langages tel que JAVA et C++. Mais d’un
autre côté, le code (qui est attaché aux images dans le scénario ou les
composants sur la scène) demande du temps pour le localiser et le
modifier. Aussi, l’abus de codes de scénario dans Flash peut rapidement
(et insensiblement) transformer un projet en un amas de codes
impossibles à maintenir.
3. Les formats Shockwave Flash (.SWF)
Tout d’abord, il faut différencier le logiciel Flash du format SWF
(Shockwave Flash), généralement appelé format Flash. Comme nous
l’avons précédemment vu, le logiciel est un outil de création de contenus et
il combine plusieurs formats.
a) Les formats d’édition
− FLA est le format de développement et de programmation. Il
permet de monter des éléments importés (images, sons, textes,
dessins vectoriels), de les animer et/ou de les programmer.
− FLV est apparu avec la version Flash MX (mars 2002) et permet
de traiter de la vidéo (montage, habillage, compression).
− AS (ActionScript) est le format des classes de Macromedia
FlashTM. Les fichiers « .as » contiennent des scripts, des classes
ou des interfaces qui seront intégrés dans un fichier « .fla ». Ce
sont des fichiers textes.
b) Le format de publication
−
SWF est un format «ouvert» de publication pour le Web. Il
nécessite un support HTML pour être identifié par le navigateur et
le plugin pour être interprété par le système d’exploitation. Ce
sont des fichiers binaires, c’est-à-dire qu’ils ne sont pas
directement exécutables par les postes clients : c’est le travail du
Flash PlayerTM, qui va se charger de finir de compiler le code et de
l’exécuter.
c) Le mode autonome
Enfin, le logiciel Flash permet aussi de générer des applications
complètes et autonomes, pour une publication off-line au format EXE,
c’est-à-dire sous la forme d’un projecteur qui contient une version réduite
du player. Nous ne développerons pas ce concept ici.
Aujourd’hui, Flash est de plus en plus utilisé pour interfacer un site Web
avec l’utilisateur final (l’Homme). Nous le verrons apparaître notamment
dans des architectures trois tiers pour des RIA.
- Page 6/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
II. Architecture trois tiers/web dynamique
Nous présentons ici les API Java au travers d’applications pour clients
légers, en nous basant sur l’architecture trois tiers. Aujourd'hui, le Web a
tout changé dans notre rapport avec le monde. Dans la majorité des cas, il
apporte une amélioration certaine dans l’utilisation des applications. Les
utilisateurs attendent toujours plus de ces « outils » (convivialité, facilité
de manipulation, ergonomie et esthétique) et iront voir ailleurs s'ils ne
trouvent satisfaction durant leur utilisation. Ils souhaitent davantage de
libertés et de flexibilité. De leur côté, les professionnels souhaitent pouvoir
communiquer en temps réel avec les particuliers et les entreprises.
Le Web a du mal à être compétitif par rapport à l'évolution actuelle des
attentes. En dépit du fait que tous l'aient adopté, le Web a ses limites en
tant que plate-forme, ce qui frustre les utilisateurs dans l'accomplissement
de leurs tâches. Le problème réside dans l'architecture du Web. Les pages
HTML sont consultées dans un navigateur, toutes les fonctions étant
conservées au niveau du serveur. En fait, quand on regarde l'historique du
design des interactions et des interfaces à partir du "mainframe"
(Ordinateur Central), le Web représente un pas en arrière en termes de
souplesse, de fonctionnalités et de puissance.
Pour combler le fossé entre les faiblesses du Web et les attentes des
utilisateurs, il faut un outil qui offrira des fonctionnalités en temps réel
pour les clients, améliorera les temps de réponse et le niveau d'interaction
des utilisateurs avec l'application, tout en gérant la logique business d'une
façon plus efficace. Il faut savoir que l’utilisation de telles applications
permet de réaliser ce que l’on appelle « l’expérience ». Quand un
utilisateur réalise une transaction sur un site de commerce en ligne, par
exemple, il arrive que celui-ci abandonne la transaction car il peut y avoir
un peu trop d’étapes pour compléter celle-ci (mauvaise « expérience »).
C’est un réel enjeu économique pour les entreprises, parce qu’elles ne
s’adaptent pas aux attentes toujours plus grandes de leurs clients et ne
leur offrent pas le contenu, les services et les données dont ils ont besoin,
elles vont perdre de l'argent (abandon fréquent de caddies et par
conséquent perte d’acheteurs potentiels, appels interminables d’utilisateurs
sur les hotlines du site pour trouver de l’aide, etc…).
Avec ce genre d’architectures, nous pouvons imaginer par exemple
l’émission d’un flux d’informations continus (RSS = Really Simple
Syndication). Ce concept est fréquemment utilisé aujourd’hui afin de
fournir dans un site Web le résumé des nouvelles provenant de sites qui
traitent les actualités, le résumé de certains blogs et autres… Ici, il est
possible d’utiliser le format XML (eXtensible Markup Language) qui est un
moyen de structurer les informations/données pour les afficher grâce à des
parseurs (analyseurs).
- Page 7/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Examinons dans un premier temps les architectures, et la façon dont Java
est utilisé pour créer des applications dynamiques, avant de nous pencher
sur les avantages de Flash.
1. Un peu d’histoire – architecture « n » tiers
Le choix des applications clients/serveur a séduit le monde de
l’entreprise car elles étaient « faciles » à déployer et mises à jour
uniquement côté serveur. Un serveur HTTP suffisait pour répondre aux
requêtes HTTP des différents clients (Internet Explorer, Mozilla, Opera,
Firefox …). Mais rapidement, les grandes entreprises comme les PME ont
souhaité pouvoir donner accès à des données stockées chez eux dans leur
Système de Gestion de Base de Données (SGBD) afin de les mettre en
forme et de les afficher sur les écrans des postes clients externes à
l’entreprise. L’architecture trois tiers faisait son apparition dans ce domaine
sous forme de postes clients connectés (via HTTP) à un serveur Web qui
lui-même accédait aux données hébergées dans un serveur de base de
données. De manière échelonnée, les sites sont passés d’une forme
statique à une forme « dynamique ». Ce dynamisme a pu être réalisé
grâce à des interfaces utilisateurs plus « riches » - ajout de processus au
niveau client pour gérer certain langage : JavaScript, applets Java et
autres. Nous en arrivons à générer dynamiquement des documents.
a) L’architecture trois tiers
Le principe de l’architecture trois tiers repose sur trois niveaux : la
couche présentation, la couche métier et la couche accès aux données.
Figure 3 – Composition d’une application trois tiers.
Les tendances actuelles en terme de développement "client léger"
s'articulent souvent autour de :
− J2EE ou .NET, qui sont des couches souples, stables d'exécution et
d'accès aux données,
− HTML, qui est une couche de présentation compliquée et non intuitive.
- Page 8/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
J2EE est une technologie Sun Microsystems®. Une application utilisant un
serveur Java permet d’absorber une charge élevée au niveau des appels
serveurs (nombre de connexions mais aussi quantité de requêtes). En
revanche, le langage HTML limite les applications.
En effet, le développement de type « client léger » est en vogue car il
permet de réaliser des applications distribuées, d’où l’architecture trois
tiers. Nous allons étudier en détail le concept de ces applications pour la
partie présentation, ce qui nous mènera à Flash qui permet de réaliser non
seulement une application de ce type, mais surtout une application
« riche ».
b) En faveur de Java/J2EE
L’avantage principal de Java/J2EE réside dans le fait que Java est
« multi-threadé » (multi-processus), par conséquent on peut envoyer « n »
requêtes simultanées sans que le service ne s’effondre.
La création d’un service est plus intuitive. Il existe une véritable école du
développement Web services Java, notamment côté J2EE. Aujourd’hui, de
nombreuses applications d’entreprises reposant sur la solution JSP
(JavaServer Pages) sont déployées. Bien que plus complexe à mettre en
œuvre et à appréhender que le PHP, le JSP a l’avantage de reposer sur le
langage Java qui est l’un des plus utilisés à travers le monde. Microsoft® a
lui aussi sa propre technologie nommée ASP (Active Server Pages). Son
inconvénient majeur est qu’il nécessite de fonctionner uniquement sur un
serveur Windows. Ceci ajoute un point fort à la technologie J2EE/JSP, car il
est tout à fait possible de développer une application sous Windows et la
déployer sur un autre système tel que Linux par exemple. Théoriquement,
un composant conforme aux services techniques J2EE doit pouvoir
s'exécuter dans n'importe quel environnement estampillé "J2EE".
Aujourd’hui, Java est reconnu aussi comme l’un des langages de
programmation les plus robustes et sécurisés pour réaliser de réelles
applications professionnelles : c’est le cas du langage Java, mais aussi les
Java Server Pages qui, sur le modèle des Active Server Pages de Microsoft,
combinent HTML et des appels à des composants pour générer des pages
dites dynamiques.
En fait, avec la norme J2EE de développement Web, on réalise des
applications qui permettent de générer dynamiquement des pages
statiques. J2EE repose sur un ensemble de librairies tel que les servlets,
JSP, XML, EJB, XML-RPC, RMI, SOAP… Ces applications reposent -entre
autres- sur l’un des modèles utilisé pour cette étude : le modèle MCV.
- Page 9/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
2. Le modèle MVC standard
L’architecture MVC est proposée par SUN. C’est la solution de
développement d’applications Web. Ce modèle de conception a pour but de
séparer la couche présentation de la couche applicative et de l’accès aux
données. Il se compose de la manière suivante :
− des sources de données représentées par le modèle (M)
− une interface utilisateur représentée par la vue (V)
− une logique applicative représentée par le contrôleur (C)
Figure 4 – Le modèle MVC
Le modèle : il représente les données métiers et la logique relative à
l'accès et à la modification de ces données. Il permet donc les traitements
des données, interactions avec la base de données, etc… Il décrit les
données manipulées par l'application et définit les méthodes d'accès. Il
consomme des servlets et génère des beans (EJB et/ou les JavaBeans).
La vue : elle traduit le contenu du modèle et spécifie la façon dont ces
données doivent être présentées. Ce sont des pages HTML/JSP (pages
HTML qui ont des références de code Java). Quant elles veulent interagir
avec l’application métier, elles sont traduites par la suite en servlets puis
exécutées côté contrôleur. La vue (pour être créée) consomme des beans.
Le contrôleur : contient des servlets qui créent des beans. Les
servlets contiennent « du code Java » qui va générer du HTML. Il définit le
comportement de l'application, il répartit les requêtes de l'utilisateur, les
transforme en actions exécutées par le modèle et sélectionne les vues pour
la présentation. Dans une application Web par exemple, il traitera
typiquement les requêtes utilisateurs à travers le protocole HTTP.
- Page 10/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
a) Les étapes de fonctionnement
Figure 5 – Les différentes étapes
A partir de la figure 5 ci-dessus, on peut décrire 5 étapes :
Etape 1 : le client envoie une requête HTTP à destination d’une servlet.
Etape 2 : la servlet récupère les données transmise dans la requête HTTP
et délègue les traitements avec/sur ces données à des composants EJB
et/ou JavaBeans.
Etape 3 : selon les traitements à effectuer, les composants EJB et/ou
JavaBean peuvent accéder à des sources de données (bases de
données,…).
Etape 4 : une fois les traitements terminés sur la source de données, les
composants rendent la main à la servlet en lui retournant le résultat. La
servlet stocke ce résultat dans un contexte (session, requête,…).
Etape 5 : la servlet transmet la suite du traitement de la requête vers une
JSP qui génère la réponse HTTP envoyée au client.
En fait, l’architecture J2EE met en pratique ce qu’on appelle communément
les composants et les conteneurs.
Les composants dans l’architecture J2EE sont des unités de développement
simple qui fournissent des fonctionnalités standardisées. Leurs interfaces
d’application sont définies et celles-ci peuvent être développées et
adaptées dans chaque entreprise de manière simple.
- Page 11/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Les conteneurs sont les services que propose J2EE. Ce sont eux qui
supportent les composants. Ces services sont standardisés et fiables.
Ainsi, J2EE offre aux développeurs la possibilité de se concentrer sur la
création des composants destinés à encapsuler certains éléments de
l’application tels que :
o
o
o
l’aspect graphique
la navigation
la logique professionnelle
Cette séparation des responsabilités rend les applications plus aisées à
maintenir, à modifier (traitements spécifiques) ou à changer (modes de
présentation), et n'influe pas sur la logique métier qui est hors de portée
des changements structurels effectués.
b) Les composants/conteneurs
Ces composants permettent de transformer les pages HTML statiques
en des écrans animés et réactifs.
i.
Les servlets
C’est la base de la programmation Web J2EE. Une servlet est un
programme Java – classe Java - qui est exécuté sur une machine où est
installé le serveur J2EE, et qui est appelé lorsqu’un navigateur client
appelle une URL (Uniform Resource Locator). Cela permet l'extension des
fonctions de ce dernier, typiquement : accès à des bases de données,
transactions d'e-commerce, etc… Ces requêtes utilisent le protocole HTTP
pour atteindre une servlet donnée. Ce sont les servlets qui permettent de
générer dynamiquement des pages HTML mais aussi -nous le verrons plus
loin- des fichiers XML, voire tout autre format destiné aux navigateurs
Web. Une servlet peut être chargée automatiquement (un fichier
default.jsp) lors du démarrage du serveur Web ou lors de la première
requête du client.
Une fois chargées, les servlets restent actives dans l'attente d'autres
requêtes du client. Une servlet chargée automatiquement se fait par le
biais d’une page HTML ou directement à partir d’un fichier JSP et un fichier
Web « .xml » qui contient le paramétrage des servlets de l’application.
L'utilisation de servlets se fait par le biais d'un conteneur de servlets
(framework) côté serveur. Celui-ci constitue l'environnement d'exécution
de la servlet et lui permet de persister entre les requêtes des clients. L'API
définit les relations entre le conteneur et la servlet. Le conteneur reçoit la
requête du client, et sélectionne la servlet qui aura à la traiter. Le
conteneur fournit également tout un ensemble de services standard pour
simplifier la gestion des requêtes et des sessions.
- Page 12/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
ii.
Les pages JSP
Une page JSP est une page HTML ou XML qui peut contenir du code Java.
C’est donc un document texte dont la base est un langage à balises (tags).
Les JSP sont exécutés par un serveur d’application pour générer la réponse
à une requête HTTP et donc identique à une servlet. La technologie JSP
permet d'insérer des fragments de code Java à l'intérieur d'une page HTML
statique, afin de la rendre dynamique.
Exemple de page JSP :
Code
Java
<% int i ;
For (i=1 ; i<= 10 ; i++)
{
Out.println ( i + "<br> " ) ;
}
%>
Code HTML
<%@page language="Java"%>
<!DOCTYPE HTML PUBLIC “-//W3c//dtd html 4.0 transitional//en”>
<html>
<head>
<title>Examen Probatoire – IPSTCNAM 2007 </title>
<body bgcolor =”#FFFFFF”>
<h1>Résultat de l’éxécution d’un code Java : </h1>
</body>
</html>
Les JSP peuvent contenir quatre éléments qui ont un rôle dans le
comportement dynamique du JSP :
o
les éléments texte qui sont formatés par HTML ou XML. C’est la
partie statique de la page.
o
les directives qui sont des instructions que traite le JSP en
compilant la page pour en faire un formulaire exécutable.
o
les balises qui font appel à JavaBeans pour générer du contenu
dynamique ou exécuter des opérations.
o
les éléments du script qui peuvent être :
ƒ des déclarations
ƒ des scriptlets
ƒ des expressions
Le JSP s'inscrit alors dans la logique de l'architecture J2EE, permettant la
séparation de la partie présentation de la partie logique d'affaires en
intégrant des données à l’aide de balises JSP spécifiques.
Notons que les pages JSP utilisent des JavaBeans. Ce sont ces derniers qui
vont accéder directement à la base de données. JSP est donc un modèle de
contenu dynamique.
- Page 13/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Le premier appel d'une page JSP entraîne la compilation côté serveur du
code Java qu'elle contient, ce qui crée une servlet stockée et gérée par le
conteneur Web.
Le conteneur de servlets le plus répandu est TomcatTM, de Apache
Software Foundation, qui a été créé au départ pour fonctionner en étroite
collaboration avec le serveur Web Apache, et qui peut maintenant
fonctionner de façon complètement autonome. L'installation d'un serveur
Web n'est d'ailleurs pas nécessaire sur une plate-forme J2EE qui sert
uniquement des pages dynamiques. Nous verrons plus loin, dans la section
Java concernant la génération de code Flash, que pour réaliser des
applications « riches », Adobe® et Laszlo Systems® utilisent un serveur
de présentation.
iii.
Les Beans
Les beans sont des composants qui s'exécutent côté serveur, de façon
répartie, entre différents processus, tout en maintenant avec le client un
état conversationnel. Les beans ou leur conteneur prendront en charge
certains aspects de ce fonctionnement ou feront appel à différents services
de la plate-forme J2EE. Il y a
deux types de beans qui sont des
composants basés sur RMI (Remote Method Invocation) : les beans entité
et les beans session, auxquels on accède à l'aide de protocoles synchrones.
Les beans orientés message, répondant aux messages JMS asynchrones,
constituent un troisième type de beans introduits dans la version 2.0 de la
spécification.
Les beans entité modélisent typiquement des objets du monde réel. Ces
objets ont besoin d'une représentation mémoire persistante, ce qui fait
qu'un bean entité pourra gérer sa propre persistance sur le mode bean
Managed Persistence (BMP), ou s'en remettre à son conteneur pour
assurer cette tâche, on parlera alors de Container Manager Persistence
(CMP).
Les beans session forment l'extension de l'application cliente manipulant la
logique métier, ils modélisent typiquement des processus ou des activités
de coordination et organisent les beans entité entre eux afin d'accomplir
des tâches spécifiques. Les concepts qu'ils représentent peuvent être
désignés par des verbes, alors que ceux qui concernent les beans entité le
sont plutôt par des noms.
Il y a deux types de beans session ; ceux dits « sans état » : l'invocation
d'une de leurs méthodes renvoie un résultat sans tenir compte des actions
d'autres composants ; ceux « avec état » : maintiennent un état
conversationnel avec l'application cliente qui les invoque, ils en sont le
prolongement au coeur de la logique métier, ils conservent des données
intéressant le client et peuvent influer sur les invocations de méthodes
suivantes.
- Page 14/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Les beans message modélisent également des processus : ils ne sont pas
tributaires d'une interface distante, mais sont invoqués par un appel
asynchrone. Ce mode de communication est primordial dans les
architectures intégratives, l'appel pouvant être initié par un système
externe à la plate-forme J2EE.
A la différence des beans entité, les beans message comme les beans
session sont tout à fait transitoires et n'ont pas de représentation
persistante.
Nous n’entrerons pas plus dans les détails de ce processus, mais ce qu’il
faut retenir ici, c’est que tout ce mécanisme permet l’interopérabilité entre
chaque partie de notre architecture.
3. L’interopérabilité
Nous en parlions précédemment : les services Web symbolisent un
mécanisme de communication entre applications distantes à travers le
réseau Internet, et ce indépendamment de tout langage de programmation
et de toute plate-forme d’exécution. Il utilise le protocole HTTP (HyperText
Transfer Protocol) comme moyen de transport ; ainsi, les communications
s’effectuent sur un support universel, maîtrisé et généralement non filtré
par les firewalls.
HTTP se trouve dans la couche 5 du Modèle OSI – c’est-à-dire la couche
session qui permet la synchronisation des communications et la gestion
des transactions. Il emploie une syntaxe basée sur la notation XML pour
décrire les appels de fonctions distantes et les données échangées et il
organise les mécanismes d’appel et de réponse. XML permet de séparer la
partie « contenu » de la partie « présentation », ce qui apporte la
possibilité de modifier le contenu (par exemple un texte) dans une page
Internet sans avoir à dessiner la page standardisée dans une page HTML
avec des feuilles de Style CSS (Cascading Style Sheet). Mais XML permet
de faciliter l’échange automatisé de contenu entre plusieurs systèmes
d’information hétérogènes.
Le but est clair : il s'agit de rendre interopérables les composants
développés dans le cadre des architectures distribuées (également
appelées architectures multi-niveaux, qui sommairement associent une
base de données, un serveur d'applications et des serveurs Web).
- Page 15/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
4. Flash et les applications distribuées
Comme nous venons de le voir, la technologie Java et J2EE permet de
réaliser des applications dont la maintenance est assez aisée. Nous
observons, au travers des sites marchands comme des applications
d’entreprises, que la navigation et l’interface utilisateur sont un peu
« lourdes ». Bien que ces systèmes offrent une grande souplesse à
l’accomplissement de nos tâches en tant qu’utilisateur, il est un peu
dommage de ne voir s’afficher à l’écran que des pages au format HTML. Ce
sont bien là des pages générées dynamiquement, mais elles restent
statiques. Ce n’est pas là leur seul inconvénient. Par exemple, pour des
applications complexes comme les réservations de billets pour un voyage,
nous sommes confrontés à une succession de pages qui pourraient être
condensées en une seule si l’on pouvait utiliser des systèmes plus
ergonomiques, à savoir similaires à ceux que l’on retrouve dans des
applications « lourdes ». Nous avons vu précédemment un concept qui
permet la création d’applications pour clients légers, mais il n’en reste pas
moins que nous sommes encore loin de celles que nous pouvons
directement installer sur nos machines, comme par exemple Microsoft
WordTM ou encore Adobe PhotoshopTM.
Dans le cadre du développement d’applications Internet, la tendance forte
actuellement est de joindre au meilleur de la technologie Web, le meilleur
de la communication et le meilleur des applications bureautiques.
Figure 6 – RIA (Rich Internet Applications)
- Page 16/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
La réponse au défi d’exploitation du potentiel d’Internet doit se faire à deux
niveaux : l’offre d’un contenant aussi intéressant que le contenu dans le
navigateur, et la présentation d’interfaces utilisateur plus « riches », plus
interactives et plus dynamiques, qui peuvent être déployées sur les
ordinateurs de bureau, mais aussi sur les nouveaux périphériques. Nous
l’avons vu en première partie, Flash représente un panel d’outils de mise
en forme alléchante de l’information et répond parfaitement à ces
nouvelles contraintes. Nous avons là tous les ingrédients de ce qui pourra
nous permettre de réaliser une nouvelle génération d’applications : les
RIA. Adobe® -comme la société Laszlo Systems®- ont bien compris que
J2EE est aujourd’hui bien implanté dans le monde de l’entreprise. Ils
proposent d’ailleurs des serveurs qui fournissent des interfaces « riches »
et évoluées au format Flash, appelées « Client Léger Riche » ou RIA,
combinant les interfaces utilisateurs « riches » et la facilité de publication
du Web. Si les entreprises souhaitent répondre à la demande d’applications
internes et externes plus ergonomiques, les entreprises devront utiliser ces
plate-formes capables de prendre en charge un large éventail
d’expériences multimédia. De telles applications permettront aux
entreprises de faciliter l’accès aux données et aux processus, de faciliter la
communication et le travail en équipe au sein de l’entreprise comme avec
l’extérieur, et de proposer des expériences interactives à leurs utilisateurs
comme à leurs clients. Voici quelques exemples de domaines d’application:
Figure 7 – Les domaines d’application
- Page 17/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
5. Technologies nécessaires
L’offre d’applications dynamiques nécessite trois technologies : des clients
dynamiques, des serveurs et des outils de développement.
Clients dynamiques : la technologie de clients dynamiques comprend les
fonctions côté client qui permettent de profiter de la puissance de
traitement des ordinateurs et périphériques. Les deux principaux facteurs
permettant de choisir une technologie de clients dynamiques sont
l’adoption de la technologie et ses capacités.
Serveurs : la connexion des clients dynamiques à la logique et aux
données des applications requiert une nouvelle technologie pour serveurs
offrant un environnement de programmation rapide, une intégration avec
les systèmes d’entreprise, la connectivité aux clients et le support des
principaux standards. Les applications dynamiques comprennent
l’intégration des communications bidirectionnelles et des données en temps
réel dans les applications (sans mentionner l’utilisation de bases de
données traditionnelles) et ont donc également besoin d’une nouvelle
génération de fonctions de communication.
Outils de développement : l’existence des technologies pour clients et
serveurs n’a de valeur qu’en combinaison avec un ensemble d’outils de
développement simplifiant la création de solutions. L’architecture
client/serveur des applications dynamiques requiert toute une panoplie
d’outils de développement étroitement liés.
Macromedia FlashTM est utilisé pour enrichir les interfaces graphiques des
sites Internet mais il existe aussi une version pour les périphériques
portables - Flash LiteTM. Adobe Macromedia® comme Laszlo Systems® ont
donc mis en place une technologie qui permet de réaliser rapidement des
interfaces utilisateurs graphiques. Nous allons aborder ces technologies,
puis l’on étudiera plus en détails la communication entre Flash et Java.
- Page 18/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
III. Interface Graphique (API/Framework)
Plusieurs solutions permettent de réaliser des interfaces graphiques
au format SWF. Il est assez difficile de dire que des API Java permettent de
générer purement du code Flash, car ce n’est pas là que réside l’intérêt
principal des API Java. Pourtant il est intéressant de comprendre les
différentes opportunités de son utilisation.
1. Opportunités de l’utilisation de Java
La première est l’utilisation d’API Java pour envoyer des informations
directement aux animations Flash que l’on peut considérer comme des
fichiers gabarits dans lesquels on va pouvoir mettre de l’information.
Prenons comme exemple un fichier Flash qui est une petite animation,
autonome ou sur une page Web connectée à Internet, et qui représenterait
par exemple le soleil, les nuages… L’utilisation de cette API, dans ce cas
précis, pourrait permettre d’envoyer des données au format XML vers cette
animation pour afficher le temps qu’il fait sur Toulouse.
Le second est l’utilisation d’API évoluées qui permettent, grâce à XML
toujours, d’utiliser des composants graphiques comme des onglets, des
tableaux dynamiques, et des méthodes avancées comme des fonctions de
base pour le tri par colonne dans un tableau, le changement de position
d’une colonne à l’autre, la sélection multiple, etc… Il existe pour cela deux
grandes familles d’outils permettant la génération de codes Flash, ou
permettant la réalisation d’applications « riches ». Nous aborderons
OpenLazsloTM de chez Laszlo Systems® et Macromedia FlexTM 2.0 de chez
Adobe®. La génération de fichiers Flash comme on l’entendrait dans
l’environnement de création Adobe Macromedia FlashTM, ne sera pas
abordée ici car ce n’est pas vraiment le rôle des API.
2. Les API Java (orientées personnalisation SWF)
Transform SWFTM de la société Flagstone® (de même que JavaSWF2,
JSwiff…) a été développé pour créer et utiliser facilement des interfaces
utilisateurs pour des applications Internet « riches ». Transform SWFTM est
un regroupement de classes pour chacun des tags et des structures de
données qui constitue la spécification de fichier Flash SWF. Ces classes
fournissent une API complètement orientée objet pour analyser, manipuler
et générer des fichiers Flash. Utiliser Transform SWFTM dans un environnement serveur permet de générer des fichiers Flash « indépendants ». Le
fichier est généré puis téléchargé vers un client pour affichage. Il pourrait
inclure du code pour envoyer/recevoir des messages XML, mais il vaut
mieux penser à Transform SWFTM en tant qu’outil de personnalisation. L’un
des utilisateurs principaux de Transform SWFTM se sert du logiciel pour
réaliser des présentations Flash pour la TV câblée et les écrans publicitaires
à travers l’Europe de l’Ouest. Là, les fichiers Flash existants sont utilisés
- Page 19/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
comme gabarits et l’information est obtenue à partir de plusieurs sources
de données et du fichier Flash final créé. Le fichier est ainsi converti en
vidéo et diffusé en continu (streaming) sur la TV câblée ou téléchargé vers
un réseau de PCs, de téléphones portables ou tout autre périphérique.
3. Les API Java évoluées (orientées RIA)
FlexTM et OpenLaszloTM sont principalement utilisés pour créer des
fichiers Flash qui ressemblent et se comportent comme des applications
bureautiques normales. On envoie et reçoit l’information normalement
sous forme de messages XML vers le serveur. Le serveur peut être
n’importe quel programme qui lit/écrit du XML : des scripts PHP, un
serveur d’applications Web comme Tomcat, etc. Nous arrivons maintenant
à voir évolué le serveur d’applications. Nous parlerons plutôt de « serveur
de présentation ». Ces deux frameworks sont préconisés pour le
développement et le déploiement d’applications Web avec des interfaces
recherchées.
4. La création de contenus « riches »
On peut utiliser Java pour créer un contenu « riche » de deux
façons :
ƒ
soit
l’on
« empaquette »
des
informations
(du
type
XML/images/animations) qui pourront être employées dans une
application Flex ou OpenLaszlo. Cette solution permet de fournir
des applications de type bureautiques (fixes ou mobiles). Il y aura
une plus grande interactivité entre l’utilisateur et l’application - le
traitement de textes ou d’images en ligne en est un exemple
évident (cf. le site http://www.picnik.com).
ƒ
soit on crée complètement le fichier Flash en Java, et l’interaction
utilisateur/application sera alors limitée. Exemple : les systèmes
de visualisation de l'information pour les actualités, la météo ou
n'importe quelle autre information dynamique. La gamme
d’applications où ce type d'informations peut être utilisé est très
large. Exemple : pour les téléphones portables, on utilisera
l'animation Flash pour obtenir une meilleure résolution
d’affichage, l’écran étant de taille réduite.
Poursuivons notre réflexion sur les applications « riches » avec du contenu
interactif et très dynamique. Pour cela, étudions cette technologie par le
biais des API FlexTM, OpenLaszloTM, Transform SWFTM et de la technologie
Java.
- Page 20/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
IV. API Java pour generer du code Flash
Reprenons le concept des applications distribuées au travers d’une
architecture trois tiers sur le modèle MVC. Cette fois-ci, le navigateur
Internet sur le poste client va pouvoir lire autre chose que du HTML. Le
plugin Flash permet aux navigateurs de lire les fichiers Flash au format
SWF (nous le décrirons plus loin) ; il comporte aussi plusieurs
connecteurs/analyseurs/convertisseurs, notamment un XMLConnector et
un parseur d’XML. Cela signifie aussi que nos pages JSP vont devoir
« générer » autre chose que du HTML. En fait, les pages JSP contiennent
du code XML et des appels aux classes Java afin d’exécuter des méthodes
dans certains « blocs » du code XML. Nous verrons qu’il est aussi possible
d’enrichir le contenu d’applications Internet évoluées avec une explication
des possibilités d’accès aux données grâce à Flex et à Java.
Il serait aussi possible d’obtenir plus d’interactivité en codant directement
en Java les effets que l’on retrouve dans des applications bureautiques,
mais ce serait assez long et fastidieux. FlexTM comme OpenLaszloTM
proposent leur plate-forme pour le déploiement d’applications Web avec
des interfaces dont le « look and feel » (le design et la sensation) est
recherché.
1. La solution Adobe Macromedia FlexTM
Adobe Macromedia FlexTM est un outil complet de création d’applications
« riches ». Il s’agit d’un serveur de présentation qui repose sur la
technologie J2EE, composé de deux entités. La première est « Flex Builder
and Flex SDK », qui est un IDE complet avec en plus l’outil de
développement et de débogage en ligne de commande SDK (Software
Developpement Kit). La seconde est « FlexBuilder Plug-in and Flex SDK »
qui est un framework (API) qui s’intègre dans un EDI plus orienté Java
comme Eclipse, bien connu de nos jours. Il inclut une vue de conception
qui permet de placer de façon apparente (« WYSIWYG » = what you see is
what you get = vous obtenez ce que vous voyez) des composants
graphiques tels que des fenêtres, des boutons, des tableaux,…
Figure 8 – EDI/API Flex
- Page 21/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
FlexTM propose aussi le FDS (Service de données Flex) qui est un ensemble
« facultatif » de composants orientés serveurs dans le serveur d’application
de J2EE. Le FDS inclut un service RPC (Remote Procedure Call) de Java qui
permet d’écrire ou de souscrire à des transmissions de messages et des
services de gestion de données. Nous traiterons cette partie qui me semble
pertinente pour les développeurs Java.
2. La solution OpenLaszloTM
OpenLaszloTM est un EDI complet 100% gratuit ce qui le met sur un
pied d’égalité avec FlexTM. Il dispose lui aussi de tous les atouts d’aide au
développement. IDE4LaszloTM est une API qui s’intègre parfaitement à la
plate-forme de développement Eclipse.
Il n’est pas nécessaire d’en dire plus sur OpenLaszloTM. Nous aborderons
les spécificités de traitements et de communication entre Java et Flash de
façon générique, en étudiant les fonctionnalités communes à toutes les API
retenues dans le cadre de cette étude.
3. Les API de Flagstone Transform SWFTM
Flagstone Software LtdTM est l’équivalent de Flex SDKTM, c’est-à-dire
qu’il ne contient que la partie API et non pas les éléments de construction
WYSIWYG contenus dans la version Builder de FlexTM et OpenLaszloTM.
Vous pourrez trouver dans la partie Annexes une traduction personnelle de
ces publications sur Internet concernant son API ainsi que celle de l’API
JavaSWF2TM.
- Page 22/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
4. Architecture de nouvelle génération
Les applications « riches » qui utilisent la technologie Flash sont
déployées sur des serveurs J2EE. Nous savons que n’importe quelle
application au format « XML » peut être compilée au format SWF, et peut
être chargée de manière statique au travers d’une page Web existante.
Cette méthode est connue comme le déploiement « serverless » car aucun
serveur de présentation n’est nécessaire. Il suffit de disposer simplement
les fichiers binaires dans un serveur Web. Il manque à ces « applications »
-déployées de cette manière- certaines fonctionnalités comme la
possibilité, par exemple, de faire tourner des services Web basés sur
SOAP (Simple Object Access Protocol) ou d’appeler des méthodes à
distance avec le langage XML.
Alternativement, les applications « riches » peuvent être déployées comme
des servlets Java traditionnelles qui sont compilées et retournées au
navigateur Web dynamiquement. Cette méthode implique que le serveur
Web exécute le serveur de présentation (Flex/OpenLaszlo). Le serveur de
présentation est lancé au travers d’une application J2EE serveur standard
ou d’un container de servlets Java.
Figure 9 – La nouvelle génération d’applications Web.
Les serveurs de présentation sont donc des servlets qui nécessitent ainsi
un serveur d’application J2EE avec un JRE (Java Runtime Environment).
Nous allons maintenant étudier les concepts de communication entre Flash
et Java.
- Page 23/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
5. La communication entre Flash et un serveur d’application Java
L’un des concepts d’utilisation de ces API est similaire au modèle de
compilation JSP. La première fois qu’une application est demandée via
HTTP sur XML (XMLConnector), elle est compilée au format binaire puis
mise en cache pour servir aux demandes suivantes.
La première fois que le développeur charge une application « riche » au
format XML (MXML/LZX), notons qu’il y a un délai d’attente assez long
avant d’obtenir l’affichage de celle-ci. Cette lenteur est due à la
compilation de l’application au format binaire. L’exécution des demandes
suivantes sera plus rapide puisque l’application sera déjà compilée. Mais en
réalité, l’application « riche » est un fichier binaire SWF. Ce fichier est
mappé dans le fichier web.xml de l’application afin de pouvoir y accéder à
partir d’un navigateur, via une URL standard.
a) Interaction entre une animation Flash et une base de données
Pour permettre l’interaction d’une animation Flash et de serveur de
présentation avec une base de données, on peut utiliser la méthode de
HTTPService. Une application « riche » peut avoir besoin d’informations
extérieures à l’application elle-même tels que les résultats d’une requête
SQL. Pour permettre cette action, Adobe® a mis à disposition l’objet
HTTPService. Les appels de HTTPService sont asynchrones. L’événement
« Résultat » est déclenché sur le HTTPService quand les données
deviennent disponibles pour l’application cliente.
Figure 10 – Accès aux données
- Page 24/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
En utilisant HTTPService, nous pouvons envoyer des demandes « http » à
un serveur n et consommer les réponses t. Bien que le HTTPService
puisse être employé pour consommer différents types de réponses, il est
typiquement employé pour consommer du XML. Nous pouvons employer
celui-ci avec n’importe quel genre de technologie se trouvant côté
serveur : JSP, Servlet, ASP, Ruby on Rails, PHP, etc. Nous indiquons pour
cela le service cible dans la propriété de l’URL de HTTPService.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" backgroundColor="#FFFFFF">
<mx:HTTPService id="srv" url="catalog.jsp"/>
n
<mx:DataGrid dataProvider="{srv.lastResult.catalog.product}" width="100%"
height="100%"/>
t
<mx:Button label="Get Data" click="srv.send()"/>n
</mx:Application>
Fichier d’exemple .mxml
En utilisant HTTPService, le fichier donné en exemple fait appel à la JSP
« catalog.jsp ». Puis DataGrid t construit un tableau dans lequel il recevra
les résultats retournés par la classe product.java. La requête est initialisée
par le bouton « GetData ».
<%@page import="flex.testdrive.store.ProductService,
flex.testdrive.store.Product,
java.util.List"%>
<?xml version="1.0" encoding="utf-8"?>
<catalog>
<%
ProductService srv = new ProductService();o
List list = srv.getProducts();
Product product;
for (int i=0; i<list.size(); i++)
{
product = (Product) list.get(i);
%>
<product productId="<%= product.getProductId()%>">q
<name><%= product.getName() %></name>
<description><%= product.getDescription() %></description>
<price><%= product.getPrice() %></price>
<image><%= product.getImage() %></image>
<category><%= product.getCategory() %></category>
</product>
<%
}
%>
</catalog>
Fichier d’exemple .jsp
Le fichier JSP réalise une instance de la classe ProductService (bean) o qui
traitera les requêtes SQL p p’ vers la base de données. Puis il récupère les
informations retournées par les requêtes q et les met en forme par le biais
de la classe Java Product.java r r’.
- Page 25/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Le bean réalise ici une requête SQL, ici une sélection de tous les champs
de la classe « product » de la base de données, classée par nom.
package flex.testdrive.store;
import
import
import
import
import
java.util.ArrayList;
java.util.List;
java.sql.*;
flex.testdrive.ConnectionHelper;
flex.testdrive.DAOException;
public class ProductService {
public List getProducts() {
ArrayList list = new ArrayList();
Connection c = null;
try {
c = ConnectionHelper.getConnection();p
Statement s = c.createStatement();
ResultSet rs = s.executeQuery("SELECT * FROM product ORDER BY name");
while (rs.next()) {
list.add(new Product(
rs.getInt("product_id"),
rs.getString("name"),
rs.getString("description"),
rs.getString("image"),
rs.getString("category"),
rs.getDouble("price")));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
c.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return list; …
Fichier d’exemple .java (javabean)
La classe Product.java, enfin un objet de la classe java (instance de la
classe), permet d’initialiser les différentes variables.
package flex.testdrive.store;
public class Product {
private int productId;
private String name;
private String description;
private String image; …
public Product() {
}
public Product(int productId, String name, String description,
String image, String category, double price) {
this.productId = productId;
this.name = name;
this.description = description;
this.image = …
}
public String getCategory() {r
return category;
}
public void setCategory(String category) {
…
Fichier d’exemple Product.java
- Page 26/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
b) Architecture et mécanisme interne du serveur de présentation
Le serveur de présentation (SDP) n’est en fait qu’une « servlet » ou
une application Java créant un pont entre l’application générée et les
composants de la machine. Il récupère les informations envoyées par
l’application Flash et les passe directement au serveur Web qui, lui, les
transmet directement à l’application Java SDP. Le SDP redirige (comme
nous l’avons vu précédemment) les requêtes vers la base de données mais
aussi vers les fichiers multimédias ou les services Web.
Le SDP s’ajoute au JRE lancé sur la machine, et lui ajoute une couche de
présentation.
Figure 11 – Architecture serveur de présentation
L’architecture d’un serveur de présentation (SDP) est divisée en trois soussystèmes principaux : le compilateur de l’interface, le gestionnaire de
données et le gestionnaire de connexions persistantes.
Le compilateur d’interface consiste en un compilateur de balises XML
(LZX/MXML), un compilateur de scripts JavaScript, un convertisseur de
média et le gestionnaire de cache.
Les deux compilateurs du gestionnaire d’interface convertissent
respectivement les balises XML de l’application et le code JavaScript en un
- Page 27/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
fichier binaire SWF exécutable par le client Flash. Durant le chargement
initial, le compilateur de l’interface génère un fichier en format SWF puis le
place dans un cache au travers du gestionnaire de cache - qui est
dépendant du gestionnaire de connexion persistante (ce qui permet de
conserver tout au long de la transaction, les propriétés de l’utilisateurs
authentifié) - à partir duquel il sera envoyé vers le client. En fonction de la
forme de l’appel du client, le fichier SWF est directement transmis ou est
inclus dans une page HTML. Le convertisseur de média permet de convertir
tout les formats de médias autorisés en un unique fichier binaire
compressé, lisible par le serveur de présentation.
Le gestionnaire de données comprend un connecteur/compilateur de
données, convertissant toutes les données binaires compressées lisibles
par le serveur de présentation et une série de connecteurs permettant à
l’application de récupérer des données via http/XML et SOAP. Les
applications « riches » peuvent ainsi interagir à travers le réseau avec les
bases de données, des services Web (WebServices), des fichiers XML et
d’objets Java.
Comme nous l’avons évoqué plus haut, le gestionnaire de connexions
persistantes gère l’authentification si nécessaire.
c) Côté client (Flash PlayerTM)
Une application « riche » fonctionne au sein d’une machine virtuelle
créée par le Flash PlayerTM, et forme sa propre architecture interne.
Le plugin Flash PlayerTM possède les avantages d’une architecture quasi
complète de déploiement des fichiers SWF et d’un environnement de rendu
graphique robuste et compact. Avec cette architecture, la solution Flash et
SDP évite la nécessité d’installation de logiciel clients supplémentaires.
Ceci permet de pallier à la difficulté de distribuer des applications sur les
différentes plates-formes existantes via le Web.
L’architecture de la machine virtuelle est divisée en trois grandes parties.
Les classes fondamentales des « frameworks » sont une librairie de
composants qui sont téléchargés à la demande, avec l’application fournie
par le SDP (aucune installation n’est requise).
Il y a quatre composants primaires :
•
le système d’évènements reconnaît et manipule les événements de
l’application (clics de la souris, manipulations des flux de données,
etc...). Il permet une programmation des évènements standards sur
le poste client basculant plus d’exécution de codes sur le CPU client.
Ceci améliore la réactivité de l’application « riche » relative aux
implémentations Web conventionnel et réduit le processus de
chargement de l’application placé sur le serveur hôte, en permettant
côté client des tâches du style tri, « processing », validation,
présentation dynamique à travers les différents états de l’application.
- Page 28/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Figure 12 – Architecture Machine virtuelle Flash PlayerTM
•
le gestionnaire de données (chargeur/lieur de données), sert de
pilote de trafic des données acceptant les flux de données à travers
le réseau à partir du SDP et des données liées (de la base de
données) jusqu’aux éléments permettant une présentation visuelle
appropriée comme des champs de texte, des tableaux, des menus …
Il joue un rôle central dans les applications « riches » incluant des
programmes qui utilisent des données mises à jour en temps réel.
•
le gestionnaire d’animation (présentation et ordonnancement)
permet aux développeurs de construire facilement une interface
dynamique de l’application avec un minimum de programmation. Il
permet aux développeurs de positionner un nombre variable
d’éléments de l’interface en utilisant le positionnement en pixels
relatif ou absolu. L’application « riche » qui en résulte s’appuie sur ce
composant pour gérer dynamiquement le positionnement des
éléments sur l’écran alors même que l’application rajoute ou enlève
des éléments de l’interface pour refléter les changements d’états de
l’application. Avec l’algorithme d’animation, les mises à jour de
l’interface écran sont rendues d’une manière fluide et continue,
- Page 29/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
communiquant clairement les changements d’états de l’application à
l’utilisateur. Ces comportements sont transparents pour les
développeurs.
•
le gestionnaire de services fournit un certain nombre de fonctions de
support utilisées par la plupart des applications. Ces services inclus
le support pour les minuteurs, le son et les dialogues asynchrones.
Les classes fondamentales augmentent les fonctions de rendu brut de
Flash Player avec des composants qui simplifient largement la création
d’applications Internet « riches ». Grâce à ces composants, l’utilisateur
final acquiert l’expérience d’une vraie interface dynamique et d’une
application plus productive.
Figure 13 – Nouvelle expérience – Source Adobe® Hôtel Broadmoor
- Page 30/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
6. La position de Sun Microsystems® sur les API Flash
Aujourd’hui, Sun Microsystems® est fortement implanté dans le
domaine de la sécurisation des données et son langage de programmation
Java est robuste. Ce respect de caractéristiques techniques lui conforte sa
place de leader dans le domaine des applications circulant via un réseau
filaire mais aussi sans fil.
Java/J2EE est une plate-forme Web qui a fait ses preuves et qui joue un
rôle pivot dans pratiquement toutes les stratégies informatiques. Il apporte
un modèle standard et ouvert à base de composants, une intégration
standardisée, un processus simple de développement de middleware, une
excellente portabilité et bien d’autres avantages permettent d’utiliser Java
comme base d’applications plus fiables, plus réutilisables, plus souples.
Java est un élément essentiel des applications Web haut de gamme.
Toutefois, il apparaît que les API Java standards livrées avec J2EE
n’incluent pas d’API permettant la génération de code Flash. J2EE est
pourtant doté d’API lui permettant de réaliser des interfaces graphiques
(composants SWING) et d’évènements entrants comme des séquences de
touches ou de mouvements de souris (le robot AWT) mais ne se compare
pas à ce que peuvent nous proposer FlexTM ou OpenLaszloTM.
- Page 31/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
V. Les autres domaines d’applications des API Java
Nous l’avons vu plus haut, il est possible d’utiliser le HTTPService et
d’accéder à des données contenues dans une base de données de manière
semblable aux JSP « traditionnelles ». Mais les frameworks présentés
permettent aussi d’utiliser différents moyens d’accéder à des données qui
peuvent être exploitées par d’autres périphériques tels que les téléphones
portables de nouvelle génération (technologie 3G), les organiseurs
électroniques (BlackBerryTM, PalmTM, Pocket PCTM, …), les consoles mobiles
de jeux
(WiiTM, PlayStationTM, …). Voici, en exemple, deux autres
méthodes d’accès aux données souvent utilisées dans ces technologies :
1. Accès aux données en utilisant les services Web
En utilisant une étiquette WebService, vous pouvez appeler (par le SOAP)
des services Web déployés dans votre serveur d’application. Les objets
retournés par les services Web sont dé-sérialisés automatiquement dans
des objets ActionScript. De même, des objets AS passés comme argument
à une opération de service Web sont agencés en accord avec la description
wsdl. Comme les HTTPServices, les appels de service Web sont
asynchrones.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" backgroundColor="#FFFFFF">
<mx:WebService id="srv" wsdl="http://coenraets.org/services/ProductWS?wsdl"
showBusyCursor="true"/>
<mx:DataGrid dataProvider="{srv.getProducts.lastResult}" width="100%"
height="100%">
<mx:columns>
<mx:DataGridColumn dataField="productId" headerText="Product Id"/>
<mx:DataGridColumn dataField="name" headerText="Name"/>
<mx:DataGridColumn dataField="price" headerText="Price"/>
</mx:columns>
</mx:DataGrid>
<mx:Button label="Get Data" click="srv.getProducts()"/>
</mx:Application>
Fichier d’exemple SampleWebService.mxml
- Page 32/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
2. Accès aux données en utilisant le RPC Java
En utilisant RemoteObject, vous pouvez directement appeler des méthodes
d’objets Java déployés dans votre serveur d’application et consommer la
valeur de retour. Les méthodes des objets de Java retournés par le côté
serveur sont dé-sérialisés dans des objets dynamiques d’ActionScript.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" backgroundColor="#FFFFFF">
<mx:RemoteObject id="srv" destination="product"/>
<mx:DataGrid dataProvider="{srv.getProducts.lastResult}" width="100%"
height="100%"/>
<mx:Button label="Get Data" click="srv.getProducts()"/>
</mx:Application>
Fichier d’exemple SamplePOJO.mxml
3. L’ouverture vers de nouveaux services
Il est important dans ces différentes méthodes d’accès aux données
de savoir choisir entre services Web, XML et Remoting pour les applications
dynamiques. Chacune de ces méthodes conviennent plus à certaines
applications que d’autres. Parmi les nouvelles applications proposées, on
retrouve par exemple :
. les services météos, qui peuvent être intégrés dans vos
pages HMTL, mais aussi en tant qu’application autonome
sur votre PC (connecté à Internet), sur vos téléphones
mobiles et autres périphériques multimédia.
. la télévision numérique, qui incruste par exemple un flux
d’informations au bas de votre écran pour vous fournir un
flash de dernière minute.
. la vidéo en continu (streaming) pour les appareils 3G et
maintenant 4G.
. les jeux vidéos Flash avec l’utilisation des mécanismes multi-joueurs en
ligne.
- Page 33/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Conclusion
Les API Java qui permettent la génération de code Flash, trouvent
principalement leur utilité via les applications Internet « riches », qui sont
en plein essor actuellement dans les vitrines du plus grand centre
commercial virtuel mondial : le World Wide Web.
D’un côté, ces nouvelles applications permettront demain aux entreprises
de générer davantage de profits, en proposant des modèles d’échanges
conviviaux et simples d’utilisation à leurs clients, tout en leur présentant
des produits (ou concepts) de façon beaucoup plus dynamique et
ergonomique, et par conséquent plus attractive. Elles faciliteront
l’e-commerce et encourageront l’augmentation du nombre de transactions.
D’autre part, ces API simplifieront davantage le développement et
réduiront le temps de réalisation des interfaces graphiques évoluées qui
permettent de créer des applications Internet « riches », d’où des
économies en termes de coûts pour les entreprises.
A l’heure actuelle fleurissent sur Internet des mini-applications « riches »
gratuites (de production) ressemblant de plus en plus à des applications
dites « lourdes » et payantes (du type Word, Powerpoint, etc…). D’ailleurs,
à la surprise générale, profitant de la sortie récente de Microsoft VistaTM,
Microsoft® parle de l’arrivée imminente sur le marché de son propre
framework de développement d’applications Internet « riches », et du
WPF/E (Windows Presentation Foundation/EverywhereTM), qui s’appuie
sur la plate-forme Microsoft .NETTM, créant ainsi une chaîne complète de
production sous un seul et même label. Est-ce à dire que demain les
applications Internet « riches » pourront menacer la survie -voire
supplanter- ces dernières, ou seront-elles uniquement complémentaire et
orientées vers la réalisation d’applications de services électroniques ou liés
à l’e-commerce ?
- Page 34/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Annexes
About Flagstone
The frameworks were developed by Flagstone to easily create rich user interfaces for web
applications. The original code was written in objective-C and were designed to be used with
Apple's excellent but under-appreciated WebObjects. The code was then ported to Java with the
release of WebObjects 5 and at the insistence of early users.
Les frameworks ont été développés par Flagstone pour créer facilement des interfaces utilisateur
pour des applications Internet riches. Le code original a été écrit dans « objectif-c » et a été conçu
pour être utilisé avec l’excellent (mais sous-apprécié) WebObjects d'Apple. Le code a été alors
porté sur Java avec la version WebObjects 5 et à l'insistance des premiers utilisateurs.
Projects/Les projets
Some of the applications which the Transform and Translate frameworks have been used for
include:
Certaines applications pour lesquelles les Frameworks « Transform » et « Translate » ont été
utilisés incluent :
Dynamic report generation with ActionScript used to control basic animation. Reports? Animation?
Actually in practice this is not an oxymoron, the idea behind using Flash and ActionScript was to
create a strong brand image for the report - particularly if the report was being viewed online.
La génération de rapport dynamique avec ActionSript contrôlait habituellement l’animation de base.
Les rapports ? L’animation ? En fait, dans la pratique, ce n’est pas un oxymoron, l’idée derrière
l’utilisation de Flash et ActionScript était de créer une image de marque forte pour créer un
rapport – en particulier si le rapport était affiché en ligne.
Dynamic generated maps - create interactive maps that add more information than is supported by
for example Google Maps or Microsoft´s MapPoint. I still think this is one of the killer apps for Flash
on the web, particularly since the graphics model is scalable this could be a great way of deploying
location based services without worrying what size of screen the map or information is being
displayed on.
Des cartes générées dynamiquement– création de cartes interactives contenant plus d'informations
qui seraient utilisées par exemple, par des cartes Google® ou par Microsoft´s MapPoint™. Je
continue à penser que c'est un critère déterminant à l’adoption de Flash sur le Web, et en
particulier puisque le modèle graphique est redimensionnable, ceci pourrait être une bonne
manière de déployer des services basés sur la localisation sans se soucier de la taille de l’écran sur
lequel la carte ou l'information seront affichées.
Creating a platform to allow small businesses to easily advertise services on TV channels. This is a
Generator style application but rather than use a scripting language for "assemble" the animation it
simply used an existing Flash file as a template. The application simply substituted the correct
images and text then rendered the Flash file to a framebuffer where it was broadcast on cable TV
channels. The whole system was very cool - with SMS integration which allowed registered users to
order the services advertised.
La création d’une plate-forme pour permettre à de petites entreprises de proposer facilement des
services sur des canaux de TV. C'est un générateur de ce type d’applications, mais plutôt que
d'employer un langage de script pour « assembler » l'animation, il a simplement employé un fichier
Flash existant comme modèle. L'application substitue les images et le texte puis renvoie le fichier
- Page 35/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Flash à une zone tampon « framebuffer » où il sera émis sur des chaînes de TéléVision câblée. Le
système entier est original - avec l'intégration de SMS qui permettent aux utilisateurs enregistrés
de commander certains services annoncés.
Real Estate Sales - this application was similar to the advertising for small businesses except that
the goal was to create an interactive tour of a property. Again templates were used to create the
basic animation. The seller drew a basic floorplan of the house (using a custom Java drawing tool)
and uploaded this along with a set of photos to a server where the complete tour could be viewed
on-line or distributed to real estate offices and used as promotional material for potential
customers in advance of visiting the property.
Ventes immobilières - cette application était semblable à celle dédiée à la publicité décrite cidessus, la seule différence étant de créer une visite interactive d'une propriété. Des modèles ont
été utilisés pour créer l'animation de base. Le vendeur dessine un plan de la maison (à l'aide d'un
outil de dessin Java spécialisé) et télécharge ceci avec un ensemble de photos sur un serveur où la
visite complète pouvait être regardée en ligne ou distribuée aux agences immobilières, et être
utilisée en tant que matériel promotionnel pour les clients potentiels avant de visiter le bien
immobilier.
These are only a few of the big projects that I know the frameworks were used for. I worked on a
couple and got to see the final results so I now understand where the frameworks do a good job
and where they could stand some improvement. Including a parser from day one was a good idea.
Having now worked with a couple schemes for that used Flash files as templates I now have a few
good ideas that will be included in the next release.
Les frameworks n’ont été employés, à ma connaissance, que sur peu de projets importants pour le
moment. J'ai travaillé sur deux d’entre eux, jusqu’ à leur achèvement, et je comprends maintenant
où les frameworks apporte un avantage précieux et où l’on pourrait améliorer ce concept.
L’utilisation d’un parseur dès le début est une bonne idée. Ayant maintenant travaillé sur différents
scenarii nécessitant que des fichiers Flash soient utilisés comme gabarit, j'ai maintenant quelques
nouvelles idées qui seront incluses dans la version suivante.
- Page 36/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Transform SWF
The Transform SWF framework is a collection of classes for each of the tags and
data structures that make up the Flash (SWF) File Format Specification from
Macromedia. The classes provide a completely object-based API for parsing,
manipulating and generating Flash files. This allows Java based applications to
dynamically generate and update files that represent animations and documents
which can be easily distributed and displayed on any platform that supports a
graphical web browser.
Le Framework « Transform SWF » est un groupement de classes pour chacun des tags
et des structures de données qui constitue la spécification de format de fichier Flash
SWF de Macromedia. Les classes fournissent un API complètement orienté objet pour
analyser, manipuler et générer des fichiers Flash. Ceci permet aux applications
basées sur Java de générer dynamiquement et mettre à jour des fichiers qui
représentent des animations et documents qui peuvent facilement être distribués et
affichés sur n’importe quelle plate-forme qui supporte un navigateur Internet
graphique.
In addition to the classes supporting the core API several classes provide a higher
level interface to reduce the level of effort required to implement applications. These
simplify the integration of sound and images into Flash file while text can be displayed
using external font files allowing presentations to be localized for any spoken
language.
En plus des classes qui supportent le cœur de l’API, plusieurs classes fournissent un
niveau d’interface plus élevé pour réduire le niveau d’effort requis pour mettre en
oeuvre les applications. Celles-ci simplifient l’intégration du son et des images dans un
fichier Flash alors que le texte peut être affiché en utilisant des fichiers de polices
externes permettant à des présentations d’être localisées pour tout langage parlé.
Features/Caractéristiques
Provides a full API for manipulating Flash MX 2004 (Flash 7).
Offre une API complète pour manipuler Flash MX 2004 (Flash 7)
Parses and encodes files from the latest version of Flash (Flash 9).
Analyse et encode des fichiers à partir de la dernière version de Flash
Object-based API is easily expanded to support future Flash versions.
L’API orienté objet est facilement extensible pour supporter les nouvelles versions de
Flash
Generate files for any version of Flash.
Génère des fichiers pour n’importe quelle version de Flash.
Parse existing Flash files to deliver customised presentations.
Analyse les fichiers Flash existant pour livrer des présentations personnalisées
Generate images using JPEG, PNG and BMP files.
Génère des images utilisant des fichiers JPEG, PNG et BMP
Generate event and soundtracks from WAV and MP3 files.
Génère des évènements et des pistes sons à partir de fichiers WAV et MP3
Display text from AWT, OpenType or TrueType font definitions.
- Page 37/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Affiche le texte à partir des définitions de polices Abstract Window Toolkit (AWT),
OpenType ou TrueType
Comprehensive 2-D drawing API to create shapes from arbitrary complex paths.
API globale de dessin 2-D pour créer des formes à partir de chemins arbitraires et
complexes.
Java 2 Standard Edition code easily integrates with web application servers.
Le code de Java 2 Standard édition est facilement intégré avec des applications
serveurs Internet.
Frameworks are available with Open Source licensing.
Les Frameworks sont disponibles en licence « Open Source ».
Transform SWF framework is covered by the Berkeley Software Distribution (BSD)
license. This allows you to release applications that use the framework in source or
binary form. The only restriction when developing Open Source or commercial
applications is that you acknowledge that Flagstone Software Ltd. retains the
copyright to the code.
Le Framework Transform SWF est couvert par la licence « Berkeley Software
Distribution (BSD) ». Ceci vous permet de publier des applications qui utilisent le
framework sous sa forme source ou binaire. La seule restriction quand on développe
des applications en Open Source ou en version commerciale est d’admettre que
Flagstone Software Ltd. possède le copyright du code.
What’s New
Last Updated: 3rd Jan 2007
2.1.6 Bug Fixes resulting from testing the framework against the library of Flash files
from a large Flash Portal web site
Dernière version : le 3 Janvier 2007
Version 2.1.6
Déboggages résultant du test du framework comparé à la bibliothèque de fichiers
Flash à partir d’un important site web Flash.
Sample Code
Flash files can be built from scratch by simply constructing instances of objects that
represent the respective Flash data structure and adding them to an FSMovie object in
the order they will be executed by the Flash player.
Les fichiers flash peuvent être construits en partant de rien, par la simple construction
d’instances d’objets qui représentent la structure de données Flash et les ajoutant à
un objet FSMovie dans l’ordre dans lequel ils seront exécutés par le lecteur « Flash
Player »
FSMovie movie = new FSMovie();
movie.setFrameSize(new FSBounds(0, 0, 400, 400));
movie.setFrameRate(1.0);
- Page 38/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
movie.add(new FSSetBackgroundColor(FSColor.lightblue()));
movie.add(new FSDefineShape(shapeId, ....));
movie.add(new FSPlaceObject2(shapeId, layer, x, y));
movie.add(new FSShowFrame());
Complex animations are created in exactly the same way: defining the objects to be
displayed then adding, updating or removing them from the display list.
Les animations complexes sont réalisées exactement de la même manière : en
définissant les objets qui seront affichés puis ajoutés, mis à jour ou supprimés à partir
de la liste d’affichage.
The movie is then encoded to transform the objects into the binary representation
that will be decoded and executed by the Flash Player:
L’animation (flash) est ensuite encodée pour transformer les objets en représentation
binaire qui pourra être décodée et exécutée par le lecteur « Flash Player »
try {
movie.encodeToFile(filename);
}
catch (Exception e) {
... Process Exception ...
}
Transform SWF can also be used to parse existing Flash files and create objects for
each of the data structures decoded from the file.
Transform SWF peut aussi être utilisé pour analyser des fichiers Flash existant et
créer des objets pour chaque structure de données décodée à partir du fichier.
try {
FSMovie movie = new FSMovie(filename);
}
catch (Exception e) {
... Process Exception ...
}
The objects may be inspected and their attributes changed accordingly allowing Flash
files to be used as templates to deliver customised presentations.
Les objets peuvent être inspectés et leurs attributs modifiés en conséquence
permettant aux fichiers Flash d’être utilisés comme gabarits pour fournir des
présentations personnalisées.
More detailed examples are available to get you started with the Transform SWF
framework and how to use the concepts supported in Flash.
Des exemples plus détaillés sont disponibles pour vous permettre de démarrer avec le
framework Transform SWF et de savoir utiliser les concepts supportés par Flash ».
- Page 39/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
High Level Examples/Exemples d’un plus haut niveau
The classes in the com.flagstone.transform.util package of the framework are
designed to make it easy to load images, sounds and fonts stored in files and
generate the objects required to display them in a movie.
Les classes dans le paquet com.flagstone.transform.util de ce framework sont
étudiées pour rendre plus aisé le chargement d’images, de sons et de polices de
caractères stockés dans les fichiers, et générer les objets requis pour les afficher dans
l’animation Flash.
FSImageConstructor generator = new FSImageConstructor("image.png");
// Generate the object containing the shape definition.
FSDefineObject image = generator.defineImage(imageId);
// All images are displayed as a bitmap fill inside a shape.
FSDefineShape3 shape = generator.defineEnclosingShape(shapeId, imageId,
-xOrigin, -yOrigin, new FSSolidLine(borderWidth, borderColor));
// Add all the objects together to display the image.
movie.add(image);
movie.add(shape);
movie.add(new FSPlaceObject2(shapeId, layer, x, y));
movie.add(new FSShowFrame());
Sounds can be played in response to events, such as a button being clicked:
Les sons peuvent être joués en réaction à un événement (exemple : un bouton sur
lequel on clique).
FSSoundConstructor generator = new FSSoundConstructor("beep.wav");
//Add the sound definition and start playing it immediately.
movie.add(generator.defineSound(soundId));
movie.add(new FSStartSound(new FSSound(soundId, FSSound.Start)));
The FSSoundConstructor class can also be used to stream sounds allowing a sound
track to be easily added to a movie:
La classe FSSoundConstructor peut aussi être utilisée pour « streamer » des sons à
partir d’une piste son pour être facilement ajoutée à l’animation :
FSSoundConstructor generator = new FSSoundConstructor("soundtrack.mp3");
- Page 40/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
// Generate the header that describes the streaming sound.
movie.add(generator.streamHeader(samplesPerBlock));
//Play a block of sound for each frame shown.
for (int i=0; i<numberOfBlocks; i++)
{
movie.add(generator.streamBlock(i, samplesPerBlock));
movie.add(new FSShowFrame());
}
Displaying text is greatly simplified using the FSTextConstructor. The class may be
used to generate simple strings using TrueType, Flash or AWT font files. Support for
blocks of text and also Unicode strings is included.
L’affichage de texte est grandement simplifié avec la classe FSTextConstructor. La
classe peut être utilisée pour générer une simple chaîne de caractères utilisant le
format de police TrueType, Flash ou AWT. Le support des blocks de textes et aussi des
caractères Unicode est inclus.
FSTextConstructor generator = new FSTextConstructor(fontId, "Arial.ttf");
String message = "Display this string.";
FSDefineText2 text = generator.defineText(textId, message, size, color);
FSDefineFont2 font = generator.defineFont();
movie.add(font);
movie.add(text);
movie.add(new FSPlaceObject2(textId, layer, x , y));
movie.add(new FSShowFrame());
The FSShapeConstructor class adds a powerful tool for drawing arbitrary paths and
complex shapes. A full range of drawing commands is supported including quadratic
and Bezier curves. The class also supports commands for drawing simple geometric
shapes.
La classe FSShapeConstructor ajoute un outil puissant pour dessiner des formes
simples ou complexes. Une gamme complète de commandes graphiques est
supportée incluant les courbes quadratiques et Bézier. La classe supporte aussi les
commandes pour dessiner une forme géométrique simple.
FSShapeConstructor path = new FSShapeConstructor();
/*
* The line and fill styles used to render the shapes should be
* specified before drawing starts.
*/
path.add(new FSSolidLine(borderWidth, borderColor));
- Page 41/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
path.add(new FSSolidFill(fillColor));
/*
* Draw a rectangle with the origin at the centre of the shape.
*/
newPath();
setStyle(0, 0);
move(xOrigin-width/2, yOrigin-height/2);
rline(width, 0);
rline(0, height);
rline(-width, 0);
rline(0, -height);
closePath();
movie.add(path.defineShape(identifier));
The simplified examples shown are to illustrate how each of the classes in the
framework are used. Detailed, working code is included on the Examples page.
Les exemples simplifiés montrés sont pour illustrer comment chacune des classes sont
utilisées dans le framework. Du code plus détaillé est disponible dans la page des
exemples :
http://www.flagstonesoftware.com/examples.html
Doc API : http://www.flagstonesoftware.com/transform/datasheets/index.html
- Page 42/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Translate AS1
Translate AS1 is a compiler for Macromedia's ActionScript language. Scripts are
compiled to generate the binary encoded actions and byte-codes that are executed by
the Flash Player when a frame is displayed; a button is clicked or when a movie clip
responds to a mouse or keyboard event. The code can be added to the objects in the
Transform SWF framework or integrated with a third-party Flash library.
Translate AS1 est un compilateur pour le langage Macromedia ActionScript. Les
scripts sont compilés pour générer les actions encodées binaires et les bytes-codes qui
sont exécutés par le lecteur « Flash Player » quand une vignette est affichée, un
bouton est cliqué ou quand un « movie clip* » qui répond à une action de la souris ou
du clavier. (*Le « Movie clip » est un objet manipulé dans Macromedia flash qui est
placé automatiquement dans une bibliothèque. Il peut être soit entièrement créé sous
Macromedia Flash soit importé. Le « Movie clip » peut être instancié sur la scène de
l’animation flash autant de fois que l’animateur flash le veut ; ce peut être une simple
image comme un graphique vectoriel avancé. Nous pouvons l’assimiler un peu comme
une classe en Java et les instances sont des objets)
Translate AS1 greatly reduces the level of effort required to implement complex
behaviours when implementing Flash files. Rather than generating individual action
objects programmatically high-level ActionScript can be used - boosting productivity
and reducing errors.
Translate AS1 réduit considérablement le niveau d’effort à fournir pour réaliser des
comportements complexes quand les fichiers Flash sont implémentés. Plutôt que de
produire une action individuelle (= code procédural), des objets d’un haut niveau de
programmation ActionScript (typage fort) peuvent être utilisés - augmentant la
productivité et réduisant le risque d’erreurs.
Features/Caractéristiques
Supports ActionScript 1.x.
Il supporte ActionScript 1.x
Create scripts for keyboard or mouse events to control movies and movie clips.
Il crée les scripts pour les actions clavier ou souris, afin de contrôler des animations
ou des “Movie Clip”.
Program on-screen buttons to implement complex application behaviour.
Il programme les boutons affichés à l’écran pour mettre en application un
comportement complexe.
Generates binary encoded actions which can be integrated with any Flash library.
Il génère des actions encodées binaires qui peuvent être intégrées avec n’importe
quelle bibliothèque Flash.
The simple API is easy to use and integrate into applications.
L’API simple est facile à utiliser et à intégrer dans des applications.
Full syntax checking and accurate error reporting.
Vérification complète de la syntaxe et rapport des erreurs à un niveau détaillé.
Support for preprocessor directives to allow conditional compilation.
Supporte des directives préprocesseur pour permettre la compilation conditionnelle.
Java 2 Standard Edition code easily integrates with web application servers.
Le code Java 2 SE s’intègre facilement avec des applications Web serveurs.
- Page 43/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Frameworks are available with Open Source licensing.
Les frameworks sont disponibles sous licence Open Source.
http://www.gnu.org/licenses/license-list.fr.html
Cette licence est basée sur les termes des licences Expat et BSD modifiée. C'est une
licence de logiciel libre permissive simple, sans gauche d'auteur et compatible avec la
GPL GNU.
Translate AS1 is currently supports ActionScript 1.x. Support for ActionScript 2.0 is
planned.
Translate AS1 supporte actuellement ActionScript 1.X. Support prévu pour
ActionScript 2.0
Les données sur les Classes :
http://www.flagstonesoftware.com/translate/datasheets/index.html
- Page 44/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Describe SWF
Ever wondered what the contents of a Flash file were ? Now with Describe SWF you
can translate the data contained in Flash files into something more meaningful.
Describe SWF is a Flash file browser. You can navigate the hierarchical data
structures in a Flash file to see how animations are created.
Vous êtes-vous jamais demandé ce que contenait un fichier Flash ? Maintenant, avec
Describe SWF, vous pouvez traduire les informations contenues dans des fichiers
Flash sous une forme beaucoup plus significative. Describe SWF est explorateur de
fichiers Flash. Vous pouvez naviguer dans les structures des données des fichiers
Flash qui sont hiérarchisées pour voir comment les animations ont été créées.
Features/Caractéristiques
Fully supports the latest version of Flash.
Il supporte entièrement la dernière version de Flash.
Outline view allows you to quickly navigate through the decoded file.
La vue d’ensemble vous permet de naviguer rapidement au travers du fichier décodé.
TextView displays the values for each field in the selected object(s).
L’afficheur de texte (TextView) montre les valeurs pour chaque champ dans les objets
sélectionnés.
Display the encoded representation of selected objects and fields, either in binary or
hex.
Il affiche la représentation encodée des objets et champs sélectionnés, au travers d’un
fichier binaire ou hexadécimal.
Full descriptions of the data structures including all fields from the Flash File format
specification are available as you browse.
Les descriptions complètes des structures de données incluant toutes les parties d’un
fichier de spécification Flash, sont disponibles pendant que vous l’explorez.
Cross platform application written using Java 2 Standard Edition.
C’est une application multi-plate-formes écrite en utilisant Java 2 SE.
Who is Describe SWF for ? Qui utilise Describe SWF ?
Describe SWF is a useful tool for developers and the curious. If you are developing
software that generates Flash files with Describe SWF you can verify that the tags you
create follow the Flash specification. Rather than trying to display the file in a Flash
Player and trying to guess the cause of any errors, with Describe SWF you can view
the individual tags which make up your file to determine if any errors exist. For the
curious Describe SWF lets you browse the contents of a Flash file and study how the
SWF specification is put into practice.
Describe SWF est un utilitaire pour les développeurs et les curieux. Si vous avez
développé un logiciel qui génère des fichiers Flash avec Describe SWF, vous pouvez
vérifier que les « tags » que vous avez créés réponde à la spécification de Flash.
Plutôt que d’essayer d’afficher le fichier dans le lecteur « Flash Player » et d’essayer
de deviner les causes des différentes erreurs, avec Describe SWF vous pouvez voir
individuellement les « Tags » qui composent votre fichier pour déterminer si des
erreurs existent. Pour les curieux, Describe SWF vous laisse passer en revue le
contenu d'un fichier Flash et étudier comment les spécifications de SWF sont mises en
pratique.
- Page 45/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
JavaSWF2 - A Java Toolkit for Macromedia
Flash(TM) Parsing and Generation
http://www.anotherbigidea.com/javaswf/
JavaSWF2 is a set of Java packages that enable the parsing, manipulation and
generation of the Macromedia Flash(TM) file format known as SWF ("swiff").
JavaSWF2 est un ensemble de “packages Java” qui permet l’analyse, la manipulation
et la génération de fichiers Macromedia Flash (TM) connus sous le nom de fichiers
swiff (« SWF »).
JavaSWF2 is available as Java source code under the JavaSWF2-BSD License - which
is a BSD License that is compatible with the GPL.
JavaSWF2 est disponible en code source Java sous la licence JavaSWF2-BSD – qui est
une licence BSD compatible avec le GPL (Licence Publique Générale GNU).
This release is of Alpha quality - which means that it is not feature complete and has
not been thoroughly tested. However, there are no known major problems as of the
date of release.
Cette version est d’une qualité Alpha – ce qui signifie que ce n’est pas un dispositif
complet et qu’il n’a pas été testé dans sa globalité. Cependant, il n’y a pas de
problèmes majeurs connus depuis la sortie de cette version.
A Yahoo Group has been set up for discussion of the code, reporting bugs and issues
and sharing comments - http://groups.yahoo.com/group/JavaSWF-Support
Un groupe Yahoo a été créé pour discuter sur le code, rapportant les bogues et les
dysfonctionnements, et partageant les commentaires :
http://groups.yahoo.com/group/JavaSWF-Support
The documentation is still rudimentary and will be improved over the next few weeks,
independently of any code releases.
La documentation est encore rudimentaire et sera améliorée au cours des semaines à
venir, indépendamment de toutes les versions du code.
- Page 46/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
The JavaSWF2-BSD License
Copyright (c) 2001, David N. Main, All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met: La redistribution et l’utilisation du code sous sa forme source ou
binaire, avec ou sans modifications, sont permises dans la mesure où les conditions suivantes sont
respectées :
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer. La redistribution du code source doit mentionner le copyright ci-dessus, cette liste de
conditions et la décharge de responsabilités suivante.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other materials provided with the distribution. Les
redistributions du code sous forme binaire doit reproduire le copyright ci-dessus, cette liste de conditions
et la décharge de responsabilités dans la documentation et/ou les autres matériaux fournis avec la
distribution.
3. The name of the author may not be used to endorse or promote products derived from this software
without specific prior written permission. Le nom de l’auteur ne doit pas être utilisé pour endosser ou
promouvoir des produits dérivés de ce logiciel sans l’obtention préalable de son autorisation écrite
spécifique.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
CE LOGICIEL EST FOURNI PAR SON AUTEUR TEL QUEL, ET CE DERNIER SE DECHARDE DE TOUTE
GARANTIE EXPRESSE OU IMPLICITE, MAIS NON LIMITEE A, DES GARANTIES IMPLICITES DE
MERCHANDISING ET FORME POUR UN BUT SPECIFIQUE ; L’AUTEUR NE SERAIT ËTRE TENU
RESPONSABLE JURIDIQUEMENT POUR TOUT DOMMAGE CAUSE DE FACON DIRECTE, INDIRECTE,
ACCIDENTELLE, SPECIALE OU EXEMPLAIRE (INCLUANT, MAIS N’ETANT PAS LIMITE A, ACHAT OU
SUBSTITUTION DE BIENS ET SERVICES, PERTE D’USAGE, DE DONNEES OU PROFITS OU INTERRUPTION
DE BUSINESS) ET DE TOUTE THEORIE DE RESPONSABILITE LEGALE, QUE CE SOIT CONTRACTUEl,
JURIDIQUE PURE OU NEGLIGENCE DECOULANT DE L’UTILISATION DE CE LOGICIEL, MEME DANS LE CAS
OU L’UTILISATEUR EST AVERTI DE L’EVENTUALITE DE TELS DOMMAGES.
- Page 47/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
JavaSWF2
Installation and Requirements
Procédure d’installation et conditions affiliées.
There are no special installation instructions - JavaSWF2 is provided as Java source
code and it is assumed that you know how to compile it.
Il n’y a pas d’instructions particulières pour l’installation – JavaSWF2 est fourni en tant
que code source de Java, et on part du principe que l’utilisateur sait le compiler.
JavaSWF2 requires JDK 1.2 (Java 2) or later.
platform dependencies.
It is pure Java and has no native
JavaSWF2 requiert le JDK 1.2 (Java2) ou plus. C’est du Java pur et il n’a aucune
dépendance par rapport à une plate-forme d’origine.
Features/Caractéristiques
JavaSWF2 provides parsing and generating facilities for Flash 4 and Flash 5 content.
JavaSWF2 fournit des outils pour analyser et générer du contenu Flash 4 et Flash 5.
Transparent JPEGs and Sound are not implemented in this release, but they are on
the list. Also - ActionScript is only supported in its compiled form (action codes) support for ActionScript source is also on the list.
Les JPEGs transparents et le son ne sont pas implémentés dans cette version, mais ils
sont sur la liste. En outre - ActionScript est seulement supporté sous sa forme
compilée (codes exécutables) - le support de la source d'ActionScript est également
sur la liste.
JavaSWF2 Architecture/L’architecture de JavaSWF2
The
code
centers
around
the
interfaces
defined
in
the
com.anotherbigidea.flash.interfaces package. These interfaces are used to pass
various information about the contents of a Flash SWF file. The SWF parsers and
writers implement these interfaces and drive other classes that implement them.
Le cœur du code se porte sur les interfaces qui sont définies dans le paquet
com.anotherbigidea.flash.interfaces. Ces interfaces sont employées pour
transmettre diverses informations sur le contenu d'un fichier Flash SWF. Les analyses
et les écritures de fichier SWF implémentent ces interfaces et pilotent d'autres classes
qui les implémentent.
There are two levels within JavaSWF2 - the file format level and a more abstract
object model. The file format level provides access to all the details of the SWF file
format - both in parsing and in writing - and is useful if you have knowledge of the file
format and need to implement fast and optimal parsing or generating code.
Il y a deux niveaux dans JavaSWF2 - le niveau de format de fichier et un niveau plus
abstrait de modèle d'objet. Le niveau de format de fichier permet d'accéder à tous les
détails d’un fichier SWF - dans l’analyse et dans l'écriture - et est utile si vous avez la
- Page 48/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
connaissance de ce format de fichier et si vous devez implémenter de façon rapide et
optimale le code analysé ou généré.
The
object
model
level
is
implemented
by
the
classes
in
the
com.anotherbigidea.flash.movie package and provides a means to access and
create SWF content without knowing all the details of the file format.
Le niveau du modèle objet est implémenté par les classes contenues dans le paquet
com.anotherbigidea.flash.movie et fournit des moyens d'accéder et créer du
contenu SWF sans connaître tous les détails du format de fichier.
Refer to the Summary of Classes below for further details.
Se référer au sommaire des classes ci-dessous pour plus de détails.
XML to/from SWF/XML vers/à partir d’un fichier SWF
The DTD for the XML representation of SWF is given in javaswf-dtd.txt
Le DTD (Documents Type Declaration – Documents des déclarations type –W3C :
http://www.w3.org/TR/2000/REC-xml-20001006 ) pour la représentation XML d’un
fichier SWF est donné dans le fichier javaswf-dtd.txt
javaswf-dtd.txt
To compile the classes mentioned below you will need the org.xml.sax.. packages in
the classpath. These are the standard SAX(2) interfaces that are included in the
JavaSWF2 releases and should also come included in all recent XML parser packages.
The Apache Xerces and Crimson parsers are recommended - but any compliant SAX2
parser will do.
Pour compiler les classes mentionnées ci-dessous, vous aurez besoin des paquets
org.xml.sax.. dans l’environnement (Path). Ce sont les interfaces SAX (2) standards
qui sont incluses dans les versions de JavaSWF2 et qui devraient également être
incluses dans tous les paquets d’analyse XML récents. Les analyseurs Apache Xerces
et Crimson sont recommandés - mais n'importe quel analyseur SAX2 conforme suffira.
(SAX = Simple API for Xml, API simple pour XML - L'originalité de cette interface est de fonctionner sous un
mode événementiel, SAX envoyant des évènements (sax events) aux outils XML au fur et à mesure de son
ananlyse. Cette approche permet de traiter un document en cours d’analyse sans attendre que l'ensemble
du document soit entièrement analysé. : http://www.megginson.com/downloads/SAX/ )
To
convert
from
SWF
to
XML
use
the
com.anotherbigidea.flash.readers.SWFSaxParser class.
This implements the
standard org.xml.sax.XMLReader interface - so it looks like an XML parser. It also
implements SWFTagTypes and so can be driven by a SWF parser. The main method
of SWFSaxParser is a command line utility to read a SWF and write out XML.
Pour convertir à partir d’un fichier SWF vers un fichier XML utiliser la classe
com.anotherbigidea.flash.readers.SWFSaxParser. Elle implémente l’interface
standard de org.xml.sax.XMLReader – afin qu’il ressemble à un analyseur d’XML. Il
implémente également SWFTagTypes et ainsi il peut être piloté par un analyseur de
SWF. La méthode principale de SWFSaxParser est un utilitaire en ligne de
commande pour lire un SWF et pour écrire XML en sortie.
To convert from XML back to SWF use the com.anotherbigidea.flash.
writers.SWFSaxWriter class. This can be driven by any SAX2 XML parser and will
drive a SWFTagTypes implementation. There is no utility provided for XML to SWF
since this would mean a dependency on a particular XML parser (until JAXP in
- Page 49/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
incorporated). However, there is a sample provided below of how to hook up the
Xerces parser to produce SWF output.
Pour retransformer un fichier XML en un fichier SWF d’origine, utiliser la classe
com.anotherbigidea.flash.writers.SWFSaxWriter. Ceci peut être piloté par
n'importe quel analyseur XML SAX2 et mènera à une implémentation de
SWFTagTypes. Il n'y a aucun utilitaire fourni pour passer du format XML à SWF
puisque ceci signifierait une dépendance sur un analyseur particulier XML (jusqu'à
JAXP incorporé ?). Cependant, il y a un exemple fourni ci-dessous de la façon de
connecter l’analyseur Xerces pour produire un fichier SWF.
Samples / Exemples
More documentation will follow. However, the following samples provide an
introduction to using JavaSWF2:
Plus de documentation suivra. Cependant, les échantillons suivants fournissent une
introduction à l’utilisation de JavaSWF2 :
How to unprotect a SWF file: See the
com/anotherbigidea/flash/Unprotector.java class in the distribution file.
Comment déprotéger un fichier SWF : Voir la classe com/anotherbigidea/flash/
Unprotector.java dans le fichier de distribution.
- Page 50/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
How to parse a SWF and dump its contents as text.
Comment analyser un SWF et « modifier » son contenu en texte.
import
import
import
import
java.io.*;
com.anotherbigidea.flash.interfaces.*;
com.anotherbigidea.flash.writers.*;
com.anotherbigidea.flash.readers.*;
/**
* Reads and parses a SWF file and dumps a textual representation
* to System.out.
* Lit et analyse le fichier SWF et convertit la représentation textuelle vers
* System.out
* SWFTagDumper is a class that implements the SWFTagTypes interface
* so it can be driven by the TagParser class.
* SWFTagDumper est une classe qui implémente l’interface SWFTagTypes
* qui peut être pilotée par la classe TagParser.
*/
public class DumpSWF
{
/**
* First arg is the name of the input SWF file
* Le premier argument est le nom du fichier SWF d’entrée. « in »
* If second arg exists then actions are decompiled - the arg is ignored
* Le second argument existe quand les actions sont compilées – L’argument est
* ignoré.
*/
public static void main( String[] args ) throws IOException
{
FileInputStream in = new FileInputStream( args[0] );
SWFTagDumper dumper = new SWFTagDumper(false, args.length > 1 );
TagParser parser = new TagParser( dumper );
SWFReader reader = new SWFReader( parser, in );
reader.readFile();
in.close();
//must flush - or the output will be lost when the process ends
//doit nettoyer - ou la sortie sera perdue quand le processus sera fini
dumper.flush();
}
}
- Page 51/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
How to extract all the static text in a movie.
Comment extraire tout texte statique dans une animation.
import java.io.*;
import java.util.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.readers.*;
import com.anotherbigidea.flash.structs.*;
/**
* Shows how to parse a Flash movie and extract all the text in Text symbols
* and the initial text in Edit Fields. Output is to System.out.
* montre comment analyser une animation Flash et extraire tout texte en symboles
* texte (Text symbols) et le texte initial en champs d’édition (Edit Fields).
*
* A "pipeline" is set up in the main method:
* Une « pipeline » est mise en place dans la méthode principale :
*
* SWFReader-->TagParser-->ExtractText
*
* SWFReader reads the input SWF file and separates out the header
* and the tags. The separated contents are passed to TagParser which
* parses out the individual tag types and passes them to ExtractText.
* SWF Reader lit le fichier SWF entré et sépare l’entête et les tags. Les
* contenus séparés sont transmis à TagParser qui analyse les types de tags
* individuels et les transmet à ExtractText.
* ExtractText extends SWFTagTypesImpl and overrides some methods.
*/
public class ExtractText extends SWFTagTypesImpl
{
/**
* Store font info keyed by the font symbol id
* Each entry is an int[] of character codes for the correspnding font glyphs
* (An empty array denotes a System Font)
*/
protected HashMap fontCodes = new HashMap();
…
- Page 52/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
How to create a simple movie at the file format level.
Comment créer une animation simple au niveau du format de fichier.
import java.io.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.structs.*;
/**
* An example of writing directly to the SWF file format interfaces.
* Create a movie consisting of 4 instances of a Movie Clip containing
* a rotating red square.
*
* Compare this to RedSquare.java
*/
public class RedSquare2
{
/**
* First arg is output filename
*/
How to create a simple movie using the object model.
Comment créer une animation simple en utilisant le modèle objet.
import java.io.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.structs.*;
import com.anotherbigidea.flash.movie*;
/**
* An example of using the Movie package to create a simple Flash movie
* consisting of 4 instances of a Movie Clip containing a rotating red
* square.
*/
public class RedSquare
{…
- Page 53/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
How to append some frames to an existing movie.
Comment apposer quelques armatures à une animation existante.
import java.io.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.readers*;
/**
* Shows how to insert a number of frames at the end of a movie.
*
* A "pipeline" is set up in the main method:
*
*
SWFReader-->AddFrames-->SWFWriter
*
* SWFReader reads the input SWF file and separates out the header
* and the tags. The separated contents are passed to AddFrames which
* passes them on to SWFWriter, which writes to the output file.
*
How to create a Movie object from an existing SWF.
Comment créer un objet d’animation à partir d'un fichier SWF existant.
import java.io.*;
import java.util.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.movie*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.readers*;
import com.anotherbigidea.flash.writers.*;
/**
* Simple example of using MovieBuilder to create a Movie object.
* Also shows that MovieBuilder creates a map of the defined symbols.
*/
public class ReadMovie
{
public static void main( String[] args ) throws Exception
{
FileInputStream in = new FileInputStream( args[0] );
- Page 54/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
How to create text using the object model.
Comment créer du texte en utilisant le modèle objet.
import java.io.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.structs.*;
import com.anotherbigidea.flash.movie.*;
/**
* Example of creating text using the Movie package.
* Copies the font glyph definitions from an existing SWF.
*/
public class TextHigh
{
/**
* arg[0] is the name of the SWF to be output. …
How to load a JPEG using the object model.
Comment charger un JPEG en utilisant le modèle d'objet.
import java.io.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.structs.*;
import com.anotherbigidea.flash.movie.*;
/**
* Example of importing a JPEG image.
*/
public class ImportJPEG
{
/**
* args[0] is filename of JPEG
* args[1] is filename of output SWF
*/ …
- Page 55/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Sample of writing frame actions.
Exemple d'écriture d’actions d’image.
import java.io.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.structs.*;
/**
* Creates an Edit Field and writes the current date/time to it in a loop
*/
public class TimeField
{
/**
* First arg is output filename
*/
public static void main( String[] args ) throws IOException
{
SWFWriter writer = new SWFWriter( args[0] );
SWFTagTypes swf = new TagWriter( writer );
swf.header( 5,
-1,
//Flash version
//unknown length
300 * SWFConstants.TWIPS, //width in twips
50 * SWFConstants.TWIPS, //height in twips
2,
//frames per sec
-1 ); //frame count to be determined
swf.tagSetBackgroundColor( new Color(255,255,255) );
//--Serif system font
swf.tagDefineFont2( 1, SWFConstants.FONT2_ANSI, "_serif", 0, 0, 0, 0,
null, null, null, null, null, null );
//--Edit Field with variable "foo"
swf.tagDefineTextField( 2, "foo", null,
new Rect( 0, 0, 6000, 600 ),
0, new AlphaColor(0,0,255,255),
- Page 56/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
How to convert an XML file to SWF.
Comment convertir un fichier XML en fichier SWF.
import java.io.*;
import java.awt.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.movie.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.util.xml.Xerces.*;
/**
* Example of converting an XML file to a SWF file.
* Key point is the use of the SWFSaxWriter class - this implements
* the standard SAX2 ContentHandler interface (via its parents) and
* can be driven directly from any compliant SAX2 XML parser.
*
* SWFSaxWriter drives an implementation of the SWFTagTypes interface.
*
* To convert SWF to XML use the main method of the
* com.anotherbigidea.flash.readers.SWFSaxParser class.
*
* The DTD for the XML is given in javaswf-dtd.txt
*
* Uses the Apache Xerces XML parser - download from apache.org.
*
* Arg[0] = input xml filename
* Arg[1] = output swf filename
VerdanaFont.swf - font used by the TextHigh.java sample.
VerdanaFont.swf - police employée par l’exemple TextHigh.java.
http://www.anotherbigidea.com/javaswf/samples/VerdanaFont.swf
- Page 57/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Summary of Classes/ Résumé des classes
Package com.anotherbigidea.flash
Unprotector
Simple Utility to unprotect a Flash movie
SWFConstants
Constants used by many of ther other packages including tag type codes and various flags
SWFActionCodes
Constants used in Action Script processing
Package com.anotherbigidea.flash.interfaces
SWFHeader
Interface for passing the SWF File Header details
SWFTags
Interface for passing the contents (as a blob) of a
SWF tag (extends SWFHeader)
SWFSpriteTagTypes
Interface for passing the details of the tags that can
be used in both the main timeline and sprite
timelines (extends SWFTags)
SWFTagTypes
Interface for passing the details of the remainder of
the tags that can only be used in the main timeline
(extends SWFSpriteTagTypes)
SWFActions
Interface for passing action codes
SWFVectors
Interface for passing Shape and Glyph vectors
SWFShape
Interface for passing Shape style definitions and
style changes (extends SWFVectors)
SWFText
Interface for passing text records as part of the
definition of the SWF Text definition tags
Package com.anotherbigidea.flash.readers
SWFReader
Reads a SWF file input stream and passes the
header and tag contents to any implementation of
the SWFTags interface.
TagParser
Implements the SWFTags interface. Parses the
contents of all tags and passes the detail to any
implementation of the SWFTagTypes interface.
ActionParser
Parses an action code array (chunk of compiled
ActionScript) and drives any implementation of the
SWFActions interface.
SWFSaxReader
Implements SWFTagTypes and the XML standard
SAX2 XMLReader interface. Converts SWF to XML.
MovieBuilder
Implements the SWFTagTypes interface and builds
an instance of the
com.anotherbigidea.flash.movie.Movie "object
model" class.
Package com.anotherbigidea.flash.writers
SWFWriter
An implementation of the SWFTags interface that
writes to an output stream or file. SWFWriter will
also calculate the length and frame count of the
movie if not known.
TagWriter
An implementation of the SWFTagTypes interface
that reconstructs the tags in binary form and writes
them to any implementation of the SWFTags
interface.
- Page 58/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
ActionWriter
An implementation of the SWFActions interface that
builds a binary action code array.
ActionTextWriter
An implementation of the SWFActions interface that
writes a textual representation of the action codes.
SWFSaxWriter
An implementation of the standard SAX2
ContentHandler interface that drives any
implementation of SWFTagTypes. When driven by a
SAX2 XML Parser will convert XML back to SWF.
SWFTagDumper
An implementation of the SWFTagTypes interface
that writes a textual representation of the entire
Flash movie.
SWFTagTypesImpl
An implementation of the SWFTagTypes interface
that passes all the method calls directly to another
implementation of the same interface. Useful as a
parent class when implementing tag filters.
SWFActionsImpl
An implementation of the SWFActions interface that
passes all the method calls directly to another
implementation of the same interface. Useful as a
parent class when implementing action filters.
DummySWFWriter
An implementation of the SWFTags interface that
does nothing - use as a sink when output is not
required.
Package com.anotherbigidea.flash.structs
...
Various structures used in the other packages
Package com.anotherbigidea.flash.movie
Movie
The root class in the Flash object model.
...
Other classes represent different symbol types in
the object model.
- Page 59/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Table des illustrations
NB : toutes les figures présentes dans cette étude ont été conçues et réalisées par mes
soins, à l’exception des figures no. 8 et 13.
FIGURE 1 – NOUVELLE GENERATION D’APPLICATIONS ................................................................................................................... 3
FIGURE 2 – EDI MACROMEDIA FLASH .......................................................................................................................................... 4
FIGURE 3 – COMPOSITION D’UNE APPLICATION TROIS TIERS. ......................................................................................................... 8
FIGURE 4 – LE MODELE MVC..................................................................................................................................................... 10
FIGURE 5 – LES DIFFERENTES ETAPES ............................................................................................................................................. 11
FIGURE 6 – RIA (RICH INTERNET APPLICATIONS)......................................................................................................................... 16
FIGURE 7 – LES DOMAINES D’APPLICATION ................................................................................................................................. 17
FIGURE 8 – EDI/API FLEX ........................................................................................................................................................... 21
FIGURE 9 – LA NOUVELLE GENERATION D’APPLICATIONS WEB. ................................................................................................... 23
FIGURE 10 – ACCES AUX DONNEES ............................................................................................................................................ 24
FIGURE 11 – ARCHITECTURE SERVEUR DE PRESENTATION.............................................................................................................. 27
FIGURE 12 – ARCHITECTURE MACHINE VIRTUELLE FLASH PLAYERTM ............................................................................................. 29
FIGURE 13 – NOUVELLE EXPERIENCE – SOURCE ADOBE® HOTEL BROADMOOR ......................................................................... 30
- Page 60/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Glossaire et Abbréviations
ActionScript
ActionScript 3.0 est un puissant langage de programmation orienté objet qui permet la création
ultra-rapide d'applications RIA. Il associe avec simplicité applications ultra-complexes,
ensembles de données volumineux et bases de code réutilisables, orientées objet. Grâce à
ActionScript 3.0, les développeurs obtiennent une productivité et des performances optimales
avec les applications Flex. Reposant sur ECMAScript, langage international normalisé de
programmation de scripts, ActionScript 3.0 est compatible avec sa spécification linguistique.
API (Application Programming Interface)
Une API est une interface de programmation normalisée permettant à un logiciel de faire appel
aux fonctions d'un autre programme déjà disponible sur une machine. Autrement dit, c’est une
bibliothèque de fonctions destinées à être utilisées par les programmeurs dans leurs
applications. Ces fonctions facilitent l'écriture des programmes en fournissant des routines
(procédures) pour gérer des éléments particuliers (affichage, pilotage de périphériques…).
Architecture trois tiers
L'architecture trois tiers (« 3-Tier » en anglais) ou architecture à trois niveaux est l'application
du modèle plus général qu'est le multi-tiers. C'est une extension du modèle client/serveur.
ASP (Active Server Pages)
C'est une technologie Web dynamique, équivalente et concurrente de PHP. Développée par la
société Microsoft, elle permet de pouvoir concevoir des sites Web proposant des fonctionnalités
insoupçonnables. En effet, cette technologie permet d'adjoindre au code HTML d'un site, des
scripts (des petits programmes) qui seront traités par le serveur Web, avant que le document
demandé ne soit renvoyé au client. Grâce à un mécanisme très permissif (COM: Component
Object Model), le service Web va ainsi pouvoir manipuler un grand nombre de ressources sur le
poste serveur (bases de données, système de fichiers, mémoire, ...).
BALISES (TAGS)
Les langages de balisage (sous-classe des langages de description) représentent une classe de
langages spécialisés dans l'enrichissement d'information textuelle. Ils opèrent grâce aux
balises, unités sémantiques délimitant chacune un ensemble à l'intérieur d'un fichier texte,
souvent en unicode.
L'inclusion de balises permet de transférer à la fois la structure du document et son contenu.
Cette structure est compréhensible par un programme informatique, ce qui autorise un
affichage personnalisé selon des règles pré-établies ; la typographie (en premier lieu la fonte)
et d'autres éléments de présentation peuvent changer. On peut de plus inclure des éléments
non-textuels.
BMP/CMP (Bean Managed Persistence/Container Managed Persistence)
Ce sont des EJB entités.
Les EJB entités sont des beans ayant majoritairement pour vocation d'être persistants, c'est-àdire pouvant être stockés sur un support physique entre deux sessions.
Les EJB entités peuvent être de deux sortes : BMP (Bean Managed Persistence) ou CMP
(Container Managed Persistence).
- Page 61/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Les EJB BMP sont des beans dont la persistance a dû être programmée par le développeur (Ce
dernier doit respecter un format pour la classe et les méthodes à implémenter sont imposées
par la norme).
Les EJB CMP sont eux des beans dont la persistance est directement assurée par le conteneur
d'EJB ; le mapping entre l'objet et son support de persistance est indiqué au conteneur via les
fichiers descripteurs de déploiement. Le développeur une fois le fichier de déploiement réalisé
n'a pas besoin d'écrire le code de persistance.
Bytecode
Le bytecode est un code-objet, intermédiaire entre le source et le binaire exécutable, utilisé en
Java pour permettre un usage multi-plate-forme de ce langage. Le code n’est donc pas
directement compréhensible par le processeur, ce qui peut provoquer certaines lenteurs. Le
bytecode est exécuté dans une VM (virtual machine). Il est appelé bytecode du fait de son
format où chaque instruction est codée sur un octet (byte en anglais), parfois suivie d'un
nombre variable de paramètres comme des registres ou des adresses mémoire.
CPU
Le CPU (Central Processing Unit) ou « Unité centrale de traitement » en français est un
processeur : c’est le composant essentiel d'un ordinateur qui interprète les instructions et traite
les données d'un programme.
CSS (Cascading Style Sheets)
Le langage CSS (Cascading Style Sheets : feuilles de style en cascade) est utilisé pour décrire
la présentation d'un document structuré écrit en HTML ou en XML, et c'est le World Wide Web
Consortium (W3C) qui en a la direction.
CSS est utilisé pour définir les couleurs, les polices, le rendu, et d'autres caractéristiques liées à
la présentation d'un document. L'objectif est de bien séparer la structure (écrite en HTML ou
similaire) et la présentation (en CSS) du document. Cette séparation fournit un certain nombre
de bénéfices, permettant d'améliorer l'accessibilité, de changer plus facilement de structure et
de présentation, et de réduire la complexité de l'architecture d'un document. Enfin, CSS permet
de s'adapter aux caractéristiques du récepteur.
HTML ne décrit que l'architecture interne, et CSS décrit tous les aspects de la présentation. CSS
peut définir couleur, police, alignement de texte, taille, position, mais aussi le formatage non
visuel, comme la vitesse à laquelle le document doit être lu par des lecteurs de texte.
EDI (Environnement de Développement Intégré)
Un EDI est un environnement de développement intégré (IDE en anglais pour Integrated
Development Environment) c’est-à-dire un programme regroupant un éditeur de texte, un
compilateur, des outils automatiques de fabrication, et souvent un débogueur.
EJB (Enterprise JavaBeans)
La technologie EJB est une architecture de composants logiciels côté serveur pour la plateforme de développement J2EE.
- Page 62/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Firewall
Ensemble de programmes conçus pour protéger les ordinateurs d’un réseau privé de tentatives
d’intrusion, de piratage ou d’infection par des virus informatiques provenant d’autres réseaux.
Sous forme de boîtiers autonomes ou de logiciel (installé sur une machine serveur ou
directement sur le PC de l’internaute), le coupe-feu filtre toutes les parcelles d’informations
(paquets) susceptibles d’entrer sur le réseau privé et détermine, en fonction de règles préétablies, s’il doit autoriser ou rejeter la communication.
FlashTM
Logiciel destiné à la création d’images graphiques animées vectorielles. Les images vectorielles
se distinguent des images classiques en ce qu’elles sont constituées exclusivement d’une série
de formes géométriques représentant des équations mathématiques. Cette technique permet
de réaliser des images de taille importante ou des animations complexes tout en conservant
une taille de fichier très réduite. Ces données sont restituées sur l’écran de l’internaute grâce à
un composant logiciel, couplé au navigateur Web. Adobe FlashTM (anciennement Macromedia
FlashTM; nom original FutureSplash AnimatorTM), ou simplement Flash, se réfère à Adobe Flash
PlayerTM et à un logiciel multimédia utilisé pour créer le contenu d’Adobe Engagement
PlatformTM. Mais le terme « Flash » peut se référer à un lecteur, un environnement ou à un
fichier d’application. Depuis son lancement en 1996, la technologie Flash est devenue une des
méthodes les plus populaires pour ajouter des animations et des objets interactifs à une page
Internet ; de nombreux logiciels de création et OS sont capables de créer ou d’afficher du Flash.
Flash est généralement utilisé pour créer des animations, des publicités ou des jeux vidéo. Il
permet aussi d'intégrer de la vidéo en streaming dans une page, jusqu'au développement
d'applications Rich Media. Les fichiers Flash, généralement appelés "animation Flash" sont au
format .swf. Ils peuvent être inclus dans une page Web et lus par le plugin Flash du navigateur,
ou bien interprétés indépendamment dans le lecteur Flash Player.
Flash PlayerTM
Adobe Flash PlayerTM est un moteur d'exécution client hautes performances et compact, garant
d'interactions puissantes et homogènes avec les principaux systèmes d'exploitation,
navigateurs, téléphones mobiles et terminaux. Flash PlayerTM, développé et distribué par Adobe
Systems® (qui acheta Macromedia® en 2005), est une application client fonctionnant sur la
plupart des navigateurs Internet. Ce logiciel permet la création de graphiques vectoriels et de
bitmap, un langage script appelé ActionScriptTM et un stream bi-directionnel de l’audio et vidéo.
C‘est un logiciel d'environnement de développement intégré (IDE) utilisé pour lire les fichiers
Flash. Adobe Flash PlayerTM 9 représente un progrès sans précédent par rapport à Flash
PlayerTM 8. Il s'agit d'un moteur d'exécution client de qualité professionnelle entièrement revu
et corrigé, capable de gérer les applications à fort pourcentage de données les plus exigeantes
sans ralentir la cadence. Il inclut une toute nouvelle ActionScript Virtual MachineTM (AVM) ultraoptimisée, baptisée AVM2, qui gère les rapports d'erreur et le débogage standard. Grâce à sa
compatibilité avec les sockets binaires, il permet aux développeurs d'étendre les fonctionnalités
du lecteur de sorte qu'il puisse fonctionner avec tout protocole binaire. Flash PlayerTM 9 se
révèle un moteur multiplate-forme encore plus sécurisé et fiable, dont Adobe FlexTM 2 utilise les
fonctionnalités.
FLEXTM
Adobe Flex™ 2 permet aux développeurs de créer une classe entièrement nouvelle
d'applications Internet riches (RIA), du fait que cette solution repose sur des technologies
nouvelles et actualisées qui leur offrent au cours du processus de développement davantage de
possibilités d'accroître la richesse des applications créées. Toutes ces technologies œuvrent
ensemble pour doper la productivité des développeurs et améliorer la satisfaction des
utilisateurs.
- Page 63/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
FRAMEWORK
Le framework (ou cadre d’applications) est l’ossature, la charpente
framework est aussi un ensemble de bibliothèques permettant le
d'applications. Il fournit suffisamment de briques logicielles pour
application aboutie. Ces composants sont organisés pour être utilisés
avec les autres.
d’une application. Un
développement rapide
pouvoir produire une
en interaction les uns
Front et back office
En informatique, le terme front office est un terme d'architecture logicielle. Il désigne la partie
qui prend en charge l'interface d'une application, par opposition au back office qui lui regroupe
la partie gestion (qui, par rapport à une architecture trois tiers, regroupe la partie métier et
données). Par analogie, on peut comparer le front office à la partie d'un magasin qui est
fréquentée par les clients, tandis que le back office correspond davantage à l'administration,
aux entrepôts, aux échanges avec les partenaires, etc…
HTML (Hypertext Markup Language)
Le HTML est le langage informatique créé et utilisé pour écrire les pages Web. Il permet en
particulier d'insérer des hyperliens dans du texte, donc de créer de l'hypertexte, d'où le nom du
langage. Techniquement, HTML est une application du Standard Generalized Markup Language
(SGML). Le développement de HTML proprement dit a cessé depuis 1999, et son successeur, le
XHTML, est une application de l'Extensible Markup Language (XML).
HTTP (HyperText Transfer Protocol)
Le http (protocole de transfert hypertexte) est une méthode d’échange de fichiers (textes,
images, multimédia) sur le Web. HTTP désigne la forme de la requête qu’un navigateur adresse
au site Web lorsque l’internaute tape une adresse Web (URL) ou clique sur un lien hypertexte.
Cette demande est formalisée par le navigateur de l’internaute en une requête HTTP. Cette
dernière sera reçue par un des logiciels fonctionnant en permanence sur le serveur Web, le
démon (daemon) HTTP et chargé d’attendre et de traiter les requêtes de pages des internautes.
Du point de vue de l’internaute, la « réponse » est la page Web demandée ou une fraction de
celle-ci. A chaque requête HTTP, une connexion TCP/IP est établie entre l’ordinateur de
l’internaute et le serveur. Pour accélérer le traitement et tenir compte du fait qu’une page Web
contient fréquemment plusieurs requêtes HTTP - les textes et les images font l’objet de
demandes séparées - la nouvelle version d’HTTP (1.1) traite désormais les demandes
consécutives « en rafale », au cours d’une seule session de communication TCP/IP.
Internet/Web
Internet est le réseau informatique mondial qui rend accessible au public des services comme le
courrier électronique et le World Wide Web. Ses utilisateurs sont désignés par le néologisme
internaute. Internet ayant été popularisé par l'apparition du World Wide Web, les deux sont
parfois confondus par le public non averti. En réalité, le Web est une des applications
d'Internet, comme le sont le courrier électronique, la messagerie instantanée ou les systèmes
de partage de fichiers poste à poste. Dans cette étude, indifféremment désigné par les
termes « Internet » ou « Web », on entendra généralement le World Wide Web.
- Page 64/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Java J2EETM (Java 2 Enterprise Edition)
Java J2EE est une spécification pour le langage de programmation Java de Sun plus
particulièrement destinée aux applications d'entreprise. Dans ce but, toute implémentation de
cette spécification contient un ensemble d'extension au framework Java standard (J2SE, Java 2
standard edition) afin de faciliter la création d'applications réparties.
JavaSWF2TM
JavaSWF2 est un ensemble de packages Java qui permet l’analyse, la manipulation et la
génération de fichiers Macromedia FlashTM connus sous le nom de fichiers SWF.
JMS (Java Message Service)
L'interface de programmation Java Message Service (JMS) permet d'envoyer et de recevoir des
messages de manière asynchrone entre applications ou composants Java. Un client peut
également recevoir des messages de façon synchrone dans le mode de communication point à
point (pour cela, il doit invoquer la méthode receive() qui est bloquante).
JSP (JavaServer Pages)
Le JSP est une technologie basée sur Java qui permet aux développeurs de générer
dynamiquement du code HTML, XML ou tout autre type de page Web. La technologie permet au
code Java et à certaines actions prédéfinies d'êtres ajoutés dans un contenu statique. La
syntaxe du JSP ajoute des balises XML, appelées actions JSP, qui peuvent être utilisées pour
appeler des fonctions. De plus, la technologie permet la création de bibliothèques de balises JSP
(taglib) qui agissent comme des extensions au HTML ou au XML. Les bibliothèques de balises
offrent une méthode indépendante de la plate-forme pour étendre les fonctionnalités d'un
serveur HTTP. Les JSP sont compilées par un compilateur JSP pour devenir des servlets Java.
Middleware
Le middleware désigne les logiciels servant d'intermédiaire entre d'autres logiciels. On utilise
généralement du middleware comme intermédiaire de communication entre des applications
complexes, distribuées sur un réseau informatique.
MXML
MXML est le langage de programmation développé par Macromedia, pour la plate-forme Flex. Il
est dérivé du XML et permet de décrire la présentation des interfaces utilisées dans le cadre du
développement des clients riches ou RIA (Rich Internet Application). Son approche déclarative
permet de contrôler plus étroitement l'aspect d'une application. Au moyen du langage MXML,
les développeurs peuvent positionner des composants et définir des contraintes garantissant
une interface utilisateur plus fluide. Ils peuvent également se servir des états de visualisation et
transitions pour contrôler la manière dont l'application doit répondre à la diversité des actions
de l'utilisateur et événements applicatifs.
Ordinateur Central (Mainframe)
Ordinateur central (mainframe en anglais) est un terme utilisé en informatique pour définir un
ordinateur de grande puissance de traitement.
Un ordinateur central fonctionne selon un modèle centralisé en opposition aux modèles répartis.
Il permet de faire tourner de façon simultanée plusieurs sessions d'un système d'exploitation ou
même de systèmes d'exploitation différents (par exemple, sous l'hyperviseur VM).
- Page 65/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Les ordinateurs centraux sont utilisés dans les très grandes compagnies (banques, compagnies
d'assurances, compagnies aériennes, compagnies de services). De par leur fiabilité et leur
puissance, ils sont parfois les seuls ordinateurs capables de répondre aux besoins de leurs
utilisateurs (traitement de très grandes banques de données accédées par des dizaines ou des
centaines de milliers d'utilisateurs).
OpenLaszloTM
OpenLaszloTM est une plate-forme de développement pour des applications Web. Elle permet de
créer des applications riches (RIA) comprenant une interface riche en fonctionnalités (drag &
drop, onglet, menu déroulant, animation etc.) tout en offrant un déploiement facilité par le biais
du navigateur internet. OpenLaszloTM est compatible avec la majorité des navigateurs internet
et des systèmes d'exploitation disposant d'un plugin Flash. OpenLaszloTM se base sur une
grammaire XML appelée LZX. LZX est une description XML et JavaScriptTM de l'application
identique, sur le principe, à XUL et XAML. Cette description déclarative permet de construire
une interface graphique très rapidement et de bénéficier d'un prototype dans un laps de temps
réduit. Le serveur OpenLaszloTM est une servlet Java qui compile l'application LZX en un binaire
exécutable. Pour l'instant, le binaire repose sur Macromedia FlashTM mais il n'est pas exclu qu'à
terme, la transformation du fichier LZX soit possible pour une autre technologie.
OS (Operating System)
Le système d'exploitation (Operating System en anglais) est un ensemble de programmes
responsables de la liaison entre les ressources matérielles d'un ordinateur et les applications de
l'utilisateur (traitement de textes, jeu vidéo…). Il assure le démarrage de l'ordinateur, et fournit
aux programmes applicatifs des points d'entrée génériques pour les périphériques
OSI (Open System Interconnexion)
Le modèle d'interconnexion en réseau des systèmes ouverts de l'ISO (Organisation
internationale de normalisation) est un modèle de communications entre ordinateurs. Il décrit
les fonctionnalités nécessaires à la communication et l'organisation de ces fonctions.
La norme complète, de référence ISO 7498 est globalement intitulée « Modèle de référence de
base pour l'interconnexion de systèmes ouverts (OSI) » et est composée de 4 parties :
•
•
•
•
Le modèle de base
Architecture de sécurité
Dénomination et adressage
Cadre général de gestion
Cette version de cet article ainsi que les articles consacrés à chacune des couches du modèle se
concentrent sur la partie 1, révision de 1994.
PHP (Hypertext PreProcessor)
Le PHP est un mécanisme très proche d'ASP mais qui est plutôt utilisé sur plate-formes
UNIX/LINUX. Malgré cela, PHP peut être supporté sur une machine Windows. Dans les deux cas
(ASP ou PHP), l'inconvénient majeur réside dans le fait que chaque requête cliente lance une
interprétation de la page à renvoyer au client.
- Page 66/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Plugin
En informatique, le terme anglais plugin (ou plug-in qui signifie brancher), est employé pour
désigner un programme qui interagit avec un logiciel principal, appelé programme hôte, pour lui
apporter de nouvelles fonctionnalités. Le terme plugin étant un anglicisme, de nombreux
termes français ont été proposés pour le remplacer : module externe, module enfichable,
module d'extension, etc… Le terme plugin provient de la métaphore de la prise électrique
standardisée et désigne une extension prévue des fonctionnalités, en comparaison des ajouts
non prévus initialement apportés à l'aide de patches. La plupart du temps, ces programmes
sont caractérisés par le fait qu’ils ne peuvent fonctionner seuls (car uniquement destinés à
apporter une fonctionnalité à un ou plusieurs logiciels), et qu’ils sont mis au point par des
personnes n'ayant pas nécessairement de relation avec les auteurs du logiciel principal.
POO (Programmation Orientée Objet)
La programmation par objet (du terme anglo-saxon Object-Oriented Programming ou OOP), est
un paradigme de programmation, il consiste en la définition et l'assemblage de briques
logicielles appelées objets ; un objet représente un concept, une idée ou toute entité du monde
physique, comme une voiture, une personne ou encore une page d'un livre.
RIA (Rich Internet Applications)
Les Rich Internet Applications (RIA) sont des applications Web qui partagent les
caractéristiques des applications autonomes sur l'ordinateur. A long terme, les RIA favorisent la
fusion des logiciels traditionnels et les logiciels client-serveur de type internet. La dimension
interactive et la vitesse d'exécution sont particulièrement soignées dans ces applications Web.
Une RIA peut être :
• exécutée sur un navigateur Internet, aucune installation n'est requise ;
• exécutée localement dans un environnement sécurisé appelé une sandbox ;
• éventuellement consultée depuis l'intérieur ou l'extérieur, d'un bureau à un autre.
Le terme "Rich Internet Application" a été introduit dans une publication de Macromedia en
mars 2002.
RMI (Remote Method Invocation)
Le RMI est une interface de programmation (API) pour le langage Java qui permet d'appeler
des objets distants. L'utilisation de cette API nécessite l'emploi d'un registre RMI sur la machine
distante hébergeant ces objets que l'on désire appeler au niveau duquel ils ont été enregistrés.
Cette interface de programmation est très souvent utilisée en parallèle avec l'API d'annuaire
JNDI ou encore avec la spécification de composants distribués transactionnels EJB du langage
Java. Cette bibliothèque qui se trouve en standard dans Java J2SE, est une technologie qui
permet la communication via le protocole HTTP entre des objets Java éloignés physiquement les
uns des autres, autrement dit s'exécutant sur des machines virtuelles java distinctes. RMI
facilite le développement des applications distribuées en masquant au développeur la
communication client / serveur.
RPC (Remote Procedure Call)
Protocole permettant de lancer une procédure d'un programme sur un ordinateur distant. Cette
méthode permet au programmeur de réaliser assez simplement des programmes ClientServeur. Exemple : si nous prenons le cas d'un client souhaitant consulter le stock d'un
fournisseur, pour pouvoir afficher la disponibilité des produits sur son site internet. Ceci peut
être réalisé à l'aide des RPC. Une procédure recevant en paramètre le numéro de produit et
renvoyant le nombre d'articles disponibles va être écrite. Cette procédure va être installée sur
l'ordinateur du fournisseur à travers un serveur d'application. Cette procédure sera ensuite
- Page 67/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
appelée depuis le programme de boutique électronique du client de façon à afficher les
disponibilités.
RSS (Really Simple Syndication)
Really Simple Syndication ou Rich Site Summary ou RDF Site Summary — une famille de
protocoles de syndication de contenu sur Internet, utilisant la technologie XML, utilisés
principalement par les sites Web d'actualités, les weblogs et les podcasts. Il est à noter que
plusieurs technologies RSS ont été développées indépendamment les unes des autres, ce qui
fait qu'il existe plusieurs significations pour le même sigle RSS. Le RSS est le résumé d'un site
représentant le cadrage des ressources. Il est un standard qui sert à syndiquer l'information de
différentes applications en permettant un affichage personnalisé par l'utilisateur de l'information
reçue.
Un flux RSS ou fil RSS (RSS feed en anglais), sigle de Really Simple Syndication (« souscription
vraiment simple »), ou de Rich Site Summary (« sommaire développé de site ») est un format
de syndication de contenu Web, codé sous forme XML. Ce système permet de diffuser en temps
réel les nouvelles des sites d'information ou des blogs, ce qui permet de rapidement consulter
ces dernières sans visiter le site.
SOAP (Simple Object Access Protocol)
C’est un protocole de RPC orienté objet bâti sur XML. Il permet la transmission de messages
entre objets distants, ce qui veut dire qu'il autorise un objet à invoquer des méthodes d'objets
physiquement situés sur une autre machine. Le transfert se fait le plus souvent à l'aide du
protocole HTTP, mais peut également se faire par un autre protocole, comme SMTP. Le
protocole SOAP est composé de deux parties : d’une part une enveloppe, contenant des
informations sur le message lui-même afin de permettre son acheminement et son traitement,
et de l’autre un modèle de données définissant le format du message, c'est-à-dire les
informations à transmettre.
URL (Uniform Resource Locator)
Une URL, de l'anglais Uniform Resource Locator, littéralement « localisateur uniforme de
ressource », est une chaîne de caractères (codé en ASCII, donc utilisant l'alphabet anglais, ce
qui signifie aucun accent comme « é » ou « î ») utilisée pour adresser les Ressources dans le
World Wide Web : document HTML, image, son, forum Usenet, boîte aux lettres électronique,
etc. Elle est informellement appelée une adresse Web.
WSDL (Web Services Description Language)
Il s'agit d'une tentative de normalisation regroupant la description des éléments permettant de
mettre en place l'accès à un service réseau (Service Web). Il fait notamment référence au
langage XML et a été proposé en 2001 au W3C pour standardisation.
XML (eXtensible Markup Language)
Langage à base de mots clés personnalisés servant à définir la structure des données dans un
document Web. Comme avec la norme HTML, il appartient au navigateur d’interpréter les mots
clés et de se conformer à leurs instructions dans la présentation des données sur l’écran de
l’internaute. Tandis qu’HTML se limite à la mise en page, XML définit la structure du document.
Les mots clés personnalisés permettent de distinguer des types de données (comme un numéro
de téléphone, une date, etc…) ou des sous parties du document Web. Ce schéma structurel des
données est lui-même disponible sur le Web et sera utilisé par le logiciel de navigation pour
identifier les types de données. De cette façon, les données voulues peuvent être « appelées »
directement par l’internaute ou un programme intermédiaire, sans avoir à télécharger ou
consulter le document Web dans son ensemble. XML est à la base de nouveaux modèles
d’échanges informatisés des données (EDI).
- Page 68/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
XML-RPC
C’est un protocole RPC (Remote Procedure Call), une spécification simple et un ensemble de
codes qui permettent à des processus s'exécutant dans des environnements différents de faire
des appels de méthodes à travers un réseau. Les processus d'invocation à distance utilisent le
protocole HTTP pour le transport des données et la norme XML pour le codage des données.
XML-RPC est conçu pour permettre à des structures de données complexes d'être transmises,
exécutées et renvoyées très facilement. XML-RPC est l'ancêtre de SOAP (voir définitions XML,
RPC et SOAP dans glossaire).
- Page 69/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
Bibliographie et références
BIBLIOGRAPHIE
Réf. :
C. Moock, Le meilleur d’ActionScript 2.0,
Ed. O’Reilly (2004), 560 pages, ISBN : 2-84177-313-2
Réf. :
P. Niemeyer & J. Knudsen, Introduction à Java 2e édition,
Ed. O’Reilly (2004), 889 pages, ISBN : 2-84177-234-9
Réf. :
P. Sarrion, Développement Web avec J2EE,
Ed. O’Reilly (2005), 235 pages, ISBN : 2-84177-380-9
Réf. :
R. Englander, Java et SOAP,
Ed. O’Reilly (2003), 270 pages, ISBN : 2-84177-230-6
Réf. :
J. Lott, ActionScript en action,
Ed. O’Reilly (2003), 915 pages, ISBN : 2-84177-286-1
Réf. :
B. McLaughlin, Java et XML,
Ed. O’Reilly (2002), 504 pages, ISBN : 2-84177-204-7
Réf. :
V. Karvir, Publication d’applications, de contenus et de communications
avec la plate-forme Flash®, Livre blanc Macromedia® (2005), 22 pages
Réf. :
Développement d’applications dynamiques pour Internet avec Macromedia
MX, Livre blanc Macromedia® (2002), 17 pages
Réf. :
B. M. Michelson, La plate-forme Macromedia Flash,
Ed. Patricia Seybold Group, (2005), 9 pages
Réf. :
J. Allaire, Macromedia Flash MX La nouvelle génération de client
multimédia, Livre blanc Macromedia® (2002), 12 pages
Réf. :
Next Generation Web Applications, Laszlo Systems Technology White Paper
(2003), 16 pages
Réf. :
K. Mullet, The Essence of Effective Rich Internet Applications, Macromedia®
White Paper (2003), 27 pages
Réf. :
Adobe® FlexTM 2, Adobe® FlexTM Technical White Paper (2003), 20 pages
- Page 70/71 -
Etudes des API JAVA pour la génération de code Flash – Patrick DUBERNET, Probatoire CNAM 2007.
________________________________________________________________________________________
REFERENCES INTERNET
9
Les API :
JavaSWF2
http://www.anotherbigidea.com/javaswf/
Flagstone Transform SWF http://www.flagstonesoftware.com/transform/index.html
Flex
9
http://www.adobe.com/devnet/flex/
http://www.adobe.com/fr/products/flex/
http://www.flex.org/
ƒ Les classes de l'API FLEX 2.0
http://livedocs.adobe.com/flex/2/langref/index.html
ƒ Norme ECMA pour création d'XML pour Flex
ECMAScript for XML (E4X) Specification
http://www.ecma-international.org/publications/standards/Ecma-357.htm
Les RIA :
Adobe :
http://www.adobe.com/fr/resources/business/rich_internet_apps/
OpenLaszlo: http://www.openlaszlo.org/
9
Ressources sur l'intégration des données :
http://WWW.adobe.com/fr/devnet/flash/data_integration.html
9
SOAP :
http://www.w3.org/TR/2003/REC-soap12-part1-20030624 (US officiel)
http://www.w3.org/2002/07/soap-translation/soap12-part0.html (FR)
9
Général :
http://fr.wikipedia.org/wiki/Portail:Informatique
http://www.infini-fr.com
http://wwww.developpez.com
- Page 71/71 -