Sur cette page
- Connaissances préalables
- Niveau de l’utilisateur
- Création de classes Java côté serveur
- Déploiement des classes Java côté serveur
- Configuration des LiveCycle Data Services pour l’utilisation des classes côté serveur
- Démarrez le serveur d’applications J2EE hébergeant des LiveCycle Data Services
- Créer un projet Flash Builder
某些 Creative Cloud 应用程序、服务和功能在中国不可用。
Cet article de développement est destiné aux développeurs Java et ActionScripts qui souhaitent créer des applications pour les LiveCycle Data Services.
Intermédiaire
Vous pouvez créer par programmation une application LiveCycle Data Services pour gérer les données situées dans une base de données relationnelle. Le service de gestion des données Adobe LiveCycle Data Services automatise la synchronisation des données entre une application cliente Adobe Flex et un niveau intermédiaire. Vous pouvez créer des applications qui assurent la synchronisation des données, la pagination des données à la demande et parfois des services d’applications connectés. De plus, vous pouvez gérer de grandes collections de données et des relations de données imbriquées, telles que les associations un à un et plusieurs à un.
L’application développée dans cet article crée manuellement les classes Java côté serveur. En d’autres termes, les classes telles que la classe Assembler sont créées à l’aide d’un IDE Java, puis déployées sur le serveur d’applications hébergeant des LiveCycle Data Services. Au lieu de créer manuellement des classes côté serveur, vous pouvez utiliser la technologie de modélisation d’Adobe. Lors de l’utilisation de la technologie de modélisation d’Adobe, les classes Java côté serveur sont créées sans avoir à les créer manuellement à l’aide d’un IDE Java. Les classes Java générées sont basées sur le modèle. L’un des avantages de la technologie de modélisation est qu’elle réduit la quantité de programmation Java nécessaire. De même, la création manuelle d’une application de gestion des données vous permet de mieux contrôler les classes côté serveur. Par exemple, vous pouvez utiliser la logique d’application Java DAO personnalisée qui existe.
Outre la création de classes Java côté serveur, vous pouvez également créer une logique d’application pour la génération d’applications clientes à l’aide de Flash Builder 4. L’illustration suivante fournit une représentation visuelle des classes Java côté serveur et de l’application cliente générée à l’aide de Flash Builder.
| Étape | Description |
| 1 | Une application cliente créée à l’aide de Flash Builder utilise des opérations exposées par la classe Assembler. Par exemple, la méthode Remplir de la classe Assembler renvoie toutes les données d’un tableau spécifique. Les données peuvent être affichées dans un contrôle tel que le contrôle Grille de données. (Une illustration de cette application cliente s’affiche après ce tableau.) |
| 2 | Les classes Java côté serveur sont déployées sur le serveur d’applications hébergeant des LiveCycle Data Services. Vous pouvez créer manuellement les classes Data Service déployées sur le serveur hébergeant Data Services. |
| 3 | Les classes Java côté serveur effectuent des opérations de base de données sur une base de données relationnelle. Par exemple, les données peuvent être récupérées et transmises à toutes les applications clientes. |
La base de données utilisée dans cet article est basée sur le tableau Product. Ce tableau se trouve dans l’exemple de base de données disponible avec LiveCycle Data Services. Le tableau Product se compose des champs suivants :
- PRODUCT_ID : spécifie une valeur d’identificateur unique pour cet élément (ce champ fait office de PK)
- NOM : spécifie le nom du produit
- CATÉGORIE : spécifie la catégorie à laquelle le produit appartient
- PRIX : stocke le prix de l’article
- IMAGE : spécifie un fichier image qui affiche l’élément
- DESCRIPTION : spécifie une description de l’élément
- QTY_IN_STOCK : spécifie le nombre d’articles en stock
L’illustration suivante présente une application cliente créée à l’aide d’un Flash Builder qui affiche les enregistrements situés dans le tableau Product. Cet article de développement décrit étape par étape comment créer cette application cliente.
Pour créer une application LiveCycle Data Service en créant manuellement les classes Java côté serveur, effectuez les tâches suivantes :
Vous créez les classes Java côté serveur dans un IDE Java tel qu’Eclipse. Ajoutez les fichiers JAR du LiveCycle Data Services sur le chemin de classe de votre projet. Incluez les fichiers flex-messaging-*.jar situés dans le répertoire suivant :
[Répertoire d’installation]/lcds/tomcat/webapps/lcds-samples/WEB-INF/lib
où [Répertoire d’installation] correspond à l’emplacement d’installation LiveCycle Data Services. Les classes Java côté serveur suivantes sont créées :
- Product : représente les données situées dans le tableau Product.
- ProductAssembler : représente la classe Assembler, qui est une classe LiveCycle Data Service requise.
- Connexion : représente une connexion à la base de données.
- DAOException : représente une exception générée en cas d’erreur de base de données.
- ProductDAO : représente la logique d’application qui effectue des opérations de base de données.
Remarque :
Toutes ces classes sont créées et déployées sur le serveur hébergeant des LiveCycle Data Services dans cet article de développement.
La classe Product représente les données situées dans le tableau Product. La classe Product contient un membre de données pour chaque champ du tableau Product. La valeur de données d’un membre de données correspond au type de données du champ. En d’autres termes, considérez le champ Description dont le type de données est VarChar.
Le type de données du membre de données de description de la classe Product est une chaîne, comme illustré dans l’exemple suivant.
description de chaîne privée ;
Le reste de la classe Product est constitué de méthodes setter et getter pour chaque membre de données. La classe Product met en œuvre
java.io.Serializable
L’exemple de code suivant représente la classe Product.
package flex.samples.product;
import java.io.Serializable;
public class Product implements Serializable {
static final long serialVersionUID = 103844514947365244L;
private int productId;
private String name;
private String description;
private String image;
private String category;
private double price;
private int qtyInStock;
public Product() {
}
public Product(int productId, String name, String description,
String image, String category, double price, int qtyInStock) {
this.productId = productId;
this.name = name;
this.description = description;
this.image = image;
this.category = category;
this.price = price;
this.qtyInStock = qtyInStock;
}
public String getCategory()
{
return category;
}
public void setCategory(String category) {
this.category = category;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getImage() {
return image;
}
public void setImage(String image) {
this.image = image;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getProductId() {
return productId;
}
public void setProductId(int productId) {
this.productId = productId;
}
public int getQtyInStock() {
return qtyInStock;
}
public void setQtyInStock(int qtyInStock) {
this.qtyInStock = qtyInStock;
}
}
La classe ProductAssembler étend la classe flex.data.assemblers.AbstractAssembler et contient les méthodes utilisées par l’application cliente. La classe Assembler contient au moins la méthode Remplir. Cette méthode met en œuvre des requêtes, chacune d’elles renvoyant une collection d’objets à l’application cliente. Si votre application cliente met à jour des objets, la classe Assembler doit inclure une méthode de synchronisation ou des méthodes individuelles de création, de mise à jour et de suppression.
L’application cliente créée dans l’article de développement appelle la méthode Remplir, qui se trouve dans la classe ProductAssembler. Notez que la méthode Remplir accepte une java.util.Listinstance en tant que paramètre d’entrée. Elle renvoie un fichier java.util.Collection qui représente les données situées dans le tableau Product.
En règle générale, il n’est pas nécessaire d’appeler directement une méthode située dans la classe Assembler. Toutefois, la méthode Remplir constitue une exception ; c’est-à-dire qu’une application cliente appelle cette méthode. Bien que vous puissiez appeler une méthode de création, de mise à jour ou de suppression située dans cette classe, elle n’est pas nécessaire puisque les LiveCycle Data Services gèrent la collecte des éléments. En d’autres termes, vous pouvez effectuer une opération de mise à jour sur les éléments d’une collection. Les modifications sont soit validées automatiquement (si autoCommit=true, la valeur par défaut), soit envoyées au serveur lorsque la méthode « commit » est appelée.
Les LiveCycle Data Services effectuent le suivi des modifications apportées aux éléments de la collection. Les modifications sont validées sur le serveur ou restaurées en réponse à la méthode revertChanges. Cette action dépend du paramètre de l’indicateur autoCommit (qui est true par défaut).
L’exemple de code suivant représente la classe ProductAssembler.
package flex.samples.product;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import flex.data.DataSyncException;
import flex.data.assemblers.AbstractAssembler;
public class ProductAssembler extends AbstractAssembler {
public Collection fill(List fillArgs, PropertySpecifier ps) {
try
{
ProductDAO service = new ProductDAO();
return service.getProducts();
}
catch (Exception e)
{
e.printStackTrace();
}
return null;
}
public Object getItem(Map identity) {
ProductDAO service = new ProductDAO();
return service.getProduct(((Integer) identity.get("productId")).intValue());
}
public void createItem(Object item) {
ProductDAO service = new ProductDAO();
service.create((Product) item);
}
public void updateItem(Object newVersion, Object prevVersion,
List changes) {
ProductDAO service = new ProductDAO();
boolean success = service.update((Product) newVersion);
if (!success) {
int productId = ((Product) newVersion).getProductId();
throw new DataSyncException(service.getProduct(productId), changes);
}
}
public void deleteItem(Object item) {
ProductDAO service = new ProductDAO();
boolean success = service.delete((Product) item);
if (!success) {
int productId = ((Product) item).getProductId();
throw new DataSyncException(service.getProduct(productId), null);
}
}
}
La classe Connection représente une connexion à la base de données. Cette classe utilise les classes Java situées dans le package fichier java.sql.*. Le code suivant représente la classe Connection. Notez que cette classe se trouve dans un package appelé flex.samples. Une instance de cette classe est créée dans la classe ProductDAO pour créer une connexion à la base de données.
package flex.samples;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectionHelper
{
private String url;
private static ConnectionHelper instance;
private ConnectionHelper()
{
try {
Class.forName("org.hsqldb.jdbcDriver");
url = "jdbc:hsqldb:hsql://localhost:9002/flexdemodb";
}
catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection() throws SQLException {
if (instance == null) {
instance = new ConnectionHelper();
}
try {
return DriverManager.getConnection(instance.url);
}
catch (SQLException e) {
throw e;
}
}
public static void close(Connection connection)
{
try {
if (connection != null) {
connection.close();
}
}
catch (SQLException e) {
e.printStackTrace();
}
}
}
La classe DAOException représente une exception qui est levée en cas d’erreur. Notez que cette classe se trouve dans un package appelé flex.samples. Le code Java suivant représente la classe DAOException.
package flex.samples;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectionHelper
{
private String url;
private static ConnectionHelper instance;
private ConnectionHelper()
{
try {
Class.forName("org.hsqldb.jdbcDriver");
url = "jdbc:hsqldb:hsql://localhost:9002/flexdemodb";
}
catch (Exception e) {
e.printStackTrace();
}
La classe ProductDAO contient une logique d’application Java qui effectue des opérations de base de données. Les méthodes de la classe Assembler appellent les méthodes situées dans cette classe pour effectuer les opérations. Vous pouvez utiliser les commandes SQL de cette classe pour effectuer des opérations de base de données. Par exemple, la logique d’application Java suivante représente une méthode appelée getProducts qui récupère les données du tableau Product.
public List getProducts() throws DAOException {
List list = new ArrayList();
Connection c = null;
try {
c = ConnectionHelper.getConnection();
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"),
rs.getInt("qty_in_stock")));
}
}
catch (SQLException e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
return list;
La méthode ConnectionHelper.getConnection renvoie une instance de Connection, qui représente une connexion à la base de données. Notez qu’une instruction SQL est utilisée pour récupérer tous les champs du tableau Product. Les enregistrements sont classés par nom et les résultats sont placés dans une java.util.Listinstance. La méthode Remplir située dans la classe ProductAssembler appelle la méthode getProducts.
La classe ProductDAO contient les méthodes suivantes :
- getProducts : renvoie les données répertoriées dans le tableau Product.
- getProductsByName : renvoie des données basées sur le nom d’un élément.
- getProduct : renvoie des données basées sur la valeur d’identificateur unique de l’élément.
- create : crée un enregistrement.
- update : met à jour un enregistrement existant.
- remove : supprime un élément de la base de données.
L’exemple de code suivant représente la classe ProductDAO.
package flex.samples.product;
import java.util.ArrayList;
import java.util.List;
import java.sql.*;
import flex.samples.ConnectionHelper;
import flex.samples.DAOException;
public class ProductDAO {
public List getProducts() throws DAOException {
List list = new ArrayList();
Connection c = null;
try {
c = ConnectionHelper.getConnection();
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"),
rs.getInt("qty_in_stock")));
}
}
catch (SQLException e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
return list;
}
public List getProductsByName(String name) throws DAOException {
List list = new ArrayList();
Connection c = null;
try {
c = ConnectionHelper.getConnection();
PreparedStatement ps = c.prepareStatement("SELECT * FROM
product WHERE UPPER(name) LIKE ? ORDER BY name");
ps.setString(1, "%" + name.toUpperCase() +
"%");
ResultSet rs = ps.executeQuery();
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"),
rs.getInt("qty_in_stock")));
}
}
catch (SQLException e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
return list;
}
public Product getProduct(int productId) throws DAOException {
Product product = new Product();
Connection c = null;
try {
c = ConnectionHelper.getConnection();
PreparedStatement ps = c.prepareStatement("SELECT * FROM
product WHERE product_id=?");
ps.setInt(1, productId);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
product = new Product();
product.setProductId(rs.getInt("product_id"));
product.setName(rs.getString("name"));
product.setDescription(rs.getString("description"));
product.setImage(rs.getString("image"));
product.setCategory(rs.getString("category"));
product.setPrice(rs.getDouble("price"));
product.setQtyInStock(rs.getInt("qty_in_stock"));
}
}
catch (Exception e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
return product;
}
public Product create(Product product) throws DAOException {
Connection c = null;
PreparedStatement ps = null;
try {
c = ConnectionHelper.getConnection();
ps = c.prepareStatement("INSERT INTO product (name,
description, image, category, price, qty_in_stock) VALUES (?, ?, ?, ?, ?,
?)");
ps.setString(1, product.getName());
ps.setString(2, product.getDescription());
ps.setString(3, product.getImage());
ps.setString(4, product.getCategory());
ps.setDouble(5, product.getPrice());
ps.setInt(6, product.getQtyInStock());
ps.executeUpdate();
Statement s = c.createStatement();
// HSQLDB Syntax to get the identity (company_id) of inserted row
ResultSet rs = s.executeQuery("CALL IDENTITY()");
// MySQL Syntax to get the identity (product_id) of inserted row
// ResultSet rs = s.executeQuery("SELECT
LAST_INSERT_ID()");
rs.next();
// Update the id in the returned object. This is important as
// this value must get returned to the client.
product.setProductId(rs.getInt(1));
}
catch (Exception e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
return product;
}
public boolean update(Product product) throws DAOException {
Connection c = null;
try {
c = ConnectionHelper.getConnection();
PreparedStatement ps = c.prepareStatement("UPDATE product
SET name=?, description=?, image=?, category=?, price=?, qty_in_stock=? WHERE
product_id=?");
ps.setString(1, product.getName());
ps.setString(2, product.getDescription());
ps.setString(3, product.getImage());
ps.setString(4, product.getCategory());
ps.setDouble(5, product.getPrice());
ps.setInt(6, product.getQtyInStock());
ps.setInt(7, product.getProductId());
return (ps.executeUpdate() == 1);
}
catch (SQLException e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
}
public boolean remove(Product product) throws DAOException {
Connection c = null;
try {
c = ConnectionHelper.getConnection();
PreparedStatement ps = c.prepareStatement("DELETE FROM
product WHERE product_id=?");
ps.setInt(1, product.getProductId());
int count = ps.executeUpdate();
return (count == 1);
}
catch (Exception e) {
e.printStackTrace();
throw new DAOException(e);
}
finally {
ConnectionHelper.close(c);
}
}
public boolean delete(Product product) throws DAOException {
return remove(product);
}
}
Après avoir créé les classes Java côté serveur, déployez-les sur le serveur hébergeant les LiveCycle Data Services. Compilez les classes Java dans votre IDE Java, puis déployez les fichiers.CLASS. L’emplacement de déploiement dépend du nom de l’application. Dans cet article de développement, on suppose que le nom de l’application est lcds-samples. Puisque les fichiers Product.class, ProductAssembler.class et ProductDAO.class font tous partie du package flex.samples.product, placez ces fichiers de classe dans le dossier suivant :
[Répertoire d’installation]\lcds\tomcat\webapps\lcds-samples\WEB-INF\classes\flex\samples\product
Puisque les classes Connection.class et DAOException.class appartiennent au package flex.samples, placez ces classes dans le dossier suivant :
[Répertoire d’installation]\lcds\tomcat\webapps\lcds-samples\WEB-INF\classes\flex\samples
Pour utiliser correctement les classes Java côté serveur, vous devez configurer le fichier data-management-config.xml. Dans ce fichier, vous créez une destination Data Management Service. Une destination correspond au point de terminaison que vous utilisez pour échanger des données afin de fournir des fonctionnalités de distribution et de synchronisation des données dans votre application cliente. Une destination est référencée dans l’application cliente.
Par défaut, le fichier data-management-config.xml se trouve dans le répertoire WEB_INF/flex de l’application Web qui contient des LiveCycle Data Services. Le fichier data-management-config.xml est référencé dans le fichier de niveau supérieur services-config.xml. L’exemple suivant montre une destination nommée stock. Notez que l’élément source fait référence à flex.samples.product.ProductAssembler. De même, l’élément de classe d’élément fait référence à flex.samples.product.Product.
<destination id="inventory">
<properties>
<source>flex.samples.product.ProductAssembler</source>
<scope>application</scope>
<item-class>flex.samples.product.Product</item-class>
<metadata>
<identity property="productId"/>
</metadata>
<network>
<paging enabled="false" pageSize="10"/>
</network>
</properties>
</destination>
La portée de l’application signifie qu’il n’existe qu’une seule instance d’Assembler pour toutes les applications clientes. L’élément de propriété d’identité est mappé à un membre de données de la classe Product. Lorsque vous utilisez la gestion des données, toutes les entités persistantes doivent posséder une ou plusieurs propriétés d’identité qui identifient de manière unique chaque instance gérée.
La pagination peut améliorer les performances des applications en réduisant les temps de requête et en réduisant la quantité de mémoire utilisée chez le consommateur. Les LiveCycle Data Services prennent en charge trois types de pagination : pagination client-serveur, pagination serveur-source de données et pagination d’association. Dans cet exemple, la pagination n’est pas activée.
Démarrez le serveur d’applications J2EE hébergeant des LiveCycle Data Services.
- Cliquez sur Démarrer, Tous les programmes, Adobe, LiveCycle Data Services ES 3.1, Démarrer le serveur LiveCycle Data Services.
Exécutez startdb.bat pour démarrer la base de données d’exemple. Ce fichier se trouve dans le répertoire suivant : [Répertoire d’installation]lcds3/sampledb.
Créez un projet Flash Builder utilisé pour créer l’application cliente. Ce projet fait référence au serveur d’applications J2EE hébergeant des LiveCycle Data Services. En d’autres termes, lorsque vous créez le projet, sélectionnez J2EE comme type de serveur d’applications et LiveCycle Data Services comme serveur d’applications. Assurez-vous que le projet référence la racine du contexte dans laquelle vous avez créé la source de données. Après avoir créé le projet, toutes les bibliothèques clientes requises pour interagir avec le serveur d’applications J2EE sont automatiquement ajoutées au chemin de classe de votre projet.
Le code MXML suivant crée une grille de données. Lorsque l’utilisateur clique sur le bouton Obtenir des données, la méthode Remplir définie dans la classe ProductAssembler est appelée. Notez que la propriété de destination est affectée au stock, qui référence la destination définie dans le fichier data-management-config.xml.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" xmlns="*"
backgroundColor="#FFFFFF">
<mx:ArrayCollection id="products"/>
<mx:DataService id="ds" destination="inventory"/>
<mx:DataGrid dataProvider="{products}"
editable="true" width="100%" height="100%">
<mx:columns>
<mx:DataGridColumn dataField="name" headerText="Name"/>
<mx:DataGridColumn dataField="category" headerText="Category"/>
<mx:DataGridColumn dataField="price" headerText="Price"/>
<mx:DataGridColumn dataField="image" headerText="Image"/>
<mx:DataGridColumn dataField="description" headerText="Description"/>
</mx:columns>
</mx:DataGrid>
<mx:Button label="Get Data" click="ds.fill(products)"/>
</mx:Application>
Vous devez également créer une classe ActionScript Product qui représente les données du tableau Product. Le fichier Product.as peut se trouver dans le même package que le fichier MXML principal. La classe d’ActionScript suivante représente le fichier Product.as.
package
{
[Managed]
[RemoteClass(alias="flex.samples.product.Product")]
public class Product
{
public function Product()
{
}
public var productId:int;
public var name:String;
public var description:String;
public var image:String;
public var category:String;
public var price:Number;
public var qtyInStock:int;
}
}
Notez que la balise RemoteClass référence flex.samples.product.Product. Tous les membres de données définis dans la classe flex.samples.product.Product sont définis dans la classe Product.as. Notez également que les types de données définis dans Product.as sont cohérents avec les membres de données définis dans flex.samples.product.Product.
Pour créer une application cliente à l’aide de Flash Builder 4, procédez comme suit :
- Démarrez Flash Builder 4 en cliquant sur Démarrer, Tous les programmes, Adobe Flash Builder 4.
- Dans la zone de nom du projet, spécifiez un nom pour votre projet.
- Sous la zone de type d’application, sélectionnez Web.
- Spécifiez la version 3.5 du SDK de Flex.
- Dans la liste de serveurs d’applications, sélectionnez J2EE.
- Cochez la case Utiliser le service d’accès à distance.
- Cochez la case LiveCycle Data Services.
- Dans la zone de dossier racine, spécifiez la valeur du dossier racine. Par exemple, spécifiez C:\lcds\tomcat\webapps\lcds-samples.
- Dans la zone de l’URL racine, spécifiez la valeur du dossier URL racine. Par exemple, spécifiez http://localhost:8400/lcds-samples/.
- Dans la zone de racine de contenu, spécifiez la valeur racine de contexte. Par exemple, spécifiez /lcds-samples.
- Acceptez la valeur par défaut du dossier de sortie.
- Cliquez sur Terminer.
- Créez la classe Product.as.
- Ajoutez la logique d’application affichée au début de cette section dans le fichier MXML.