Mappage d'extension

Exemple

Le code suivant présente un exemple de classe d'extenseur pour une classe BOM nommée EventDispatcher.

public class DispatcherExtender {
  /**
   * This extender method implements
   * EventDispatcher.exception(FinancialEvent, String) 
   */
  public static void exception(GenericObject dispatcher, 
                               GenericObject event, 
                               String message) {
    System.out.println("###> Processing Exception : event " 
                                         + event + message + "<###");
  }
  
  /**
   * This extender method implements
   * EventDispatcher.send(FinancialEvent, String) 
   */
  public static void send(GenericObject dispatcher, 
                          GenericObject event, 
                          String target) {
    System.out.println("===> Sending " + event + " to " + target + " <===");
  }
}

Mappage avec testeur de classe

Le mappage entre une classe métier et une classe d'exécution peuvent devenir complexe. Par exemple, vous pouvez avoir plusieurs classes métier mappées à une même classe d'exécution. Pour faciliter le mappage, vous pouvez spécifier un testeur pour tester les instances de la classe d'exécution.

Par exemple, vous avez une classe métier RichCustomer qui correspond à une classe d'exécution Customer :

• Définissez Nom d'exécution surCustomer.

• Définissez Nom de l'extension surRichCustomerExt. Cette classe n'a pas de conventions de dénomination.

• Entrez le code suivant dans leTesterChamp :

  
  public static boolean tester(Customer customer) {
    return customer.money > 100000;
  }
  

  Le code indique que la méthode du testeur est une méthode statique Java de la classe d'extension nommée tester. Elle renvoie une valeur booléenne (boolean) et prend la classe d'exécution Customer comme paramètre.

Mappage d'un attribut à une expression pour renvoyer une valeur

Vous pouvez utiliser le mappage d'extension pour mapper un attribut BOM à une expression et renvoyer une valeur d'attribut à l'exécution.

Dans cet exemple, la méthode utilisée lors de l'accès à l'attribut averageItemPrice est fournie en tant que méthode statique Java nommée getAverageItemPrice:

public class CartExtender {
  public static double getAverageItemPrice(ShoppingCart cart) {
    if (cart.getNumberOfItems() == 0)
      return 0;
    return cart.getValue()/ cart.getNumberOfItems();    
  }
}

Mappage d'un attribut à une expression pour définir une valeur

Vous pouvez mapper un attribut BOM à une expression qui définit la valeur de l'attribut à l'exécution.

Dans cet exemple, la méthode utilisée lors de l'accès à l'attribut averageItemPrice est fournie en tant que méthode statique Java nommée setAverageItemPrice:

public class CartExtender {  
  public static void setAverageItemPrice(ShoppingCart cart, double v) {
    cart.setValue(cart.getNumberOfItems()*v);
  }
}

Mappage d'appel de méthode

Vous pouvez mapper un appel de méthode à une expression spécifiée.

Dans cet exemple, la méthode utilisée lorsque la méthode isOlderThan est appelée est fournie en tant que méthode statique Java portant le même nom dans la classe d'extension:

public class ExtCustomer {  
  public static boolean isOlderThan(Customer customer, int age) {
    return customer.getAge() > age;
  }
}

Mappage d'appel de constructeur

Vous pouvez mapper un appel de constructeur à n'importe quelle expression.

Dans cet exemple, la méthode utilisée lorsque le constructeur est appelé est fournie en tant que méthode statique Java appelée create:

public class ExtCustomer {  
  public static Customer create(String name, int age) {
    Customer c = new Customer(name);
    c.setAge(age);
    return c;
  }
}

Mappage d'objet synthétique

Vous pouvez utiliser un objet synthétique pour simuler l'état d'objets réels. A l'instar d'un objet réel, un objet synthétique peut stocker des attributs. Les objets SDO (Service Data Objects) constituent un exemple de structure d'objet synthétique. Vous pouvez utiliser des objets synthétiques à la place d'objets Java standard en tant que données d'application. Vous pouvez ensuite utiliser le mappage BOM–XOM pour implémenter un modèle d'objet métier complet n'utilisant que des objets synthétiques.

Indiquez le nom de la classe d'extenseur dans la zone Nom d'extenseur et celui de la classe d'exécution dans la zone Nom d'exécution.

Dans cet exemple, la classe d'extenseur définit tous les mappages nécessaires à l'interface de la classe d'exécution java.util.Map :

import java.util.*;
public class CustomerExtender {
  public static String getName(Map customer) {
    return (String) customer.get("name");
  }

  public static int getMoney(Map customer) {
    return ((Integer) customer.get("money")).intValue();
  }

  public static void setMoney(Map customer, int value) {
    customer.put("money", new Integer(value));
  }

  public static Map create(String name) {
    Map result = new HashMap(3);
    result.put("name", name);
    result.put("money", new Integer(0));
    // as assumed it always contains an Integer
    result.put("className", "Customer");
    return result;
  }

  public static boolean tester(Map customer) {
    return "Customer".equals(customer.get("className"));
  }
}