Seite412

• 4.1.2 Definition der Schnittstelle zwischen Präsentations- und Logikschicht
  • JNDI
  • ServiceLocator
  • Manager-Schnittstellen
  • Implementierung der Manager-Schnittstellen
  • ManagerFactory

4.1.2 Definition der Schnittstelle zwischen Präsentations- und Logikschicht

Präsentationsschicht und Geschäftslogikschichten teilen sich das Remote-Interface des CustomerSessionBeans.

JNDI

Auf Clientseite wird davon ausgegangen, dass das Bean über JNDI, der auf localhost:1099 läuft, über den Namen "CustomerSessionBean/remote" geholt werden kann, weil es unter diesem Namen beim Namensdienst auf Serverseite registriert wurde. Auf Client-Seite existiert speziell eine Klasse ServiceLocator, die den Aufruf des Namensdienstes und das Holen der Bean-Referenz kapselt.

Diese Datei muss sich beim Ausführen des Programms im Klassenpfad befinden: jndi.properties

java.rmi.server.codebase=http://localhost/java/rmi
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost:1099

Durch diese Properties-Datei kann im ServiceLocator auf das direkte Setzen der Properties im Code des Konstrukturs über System.getProperties() sowie das direkte Setzen der Umgebungsvariablen des InitialContexts verzichtet werden.

Hinweis zur Verwendung von JNDI: Die JNDI-Benamung ist nicht standardisiert sondern abhängig vom jeweilig verwendeten Anwendungsserver: EJB 3 Portability Issue: why JNDI names are not standardized.

ServiceLocator

   public class ServiceLocator {

      private static ServiceLocator serviceLocator = null;
      private Context context = null;
      public enum RemoteBusinessService {
              AddressService, ArticleService, ArticleTypeService, InvoiceService, 
              CustomerService, PersonService
      };

      private ServiceLocator() throws ServiceException {
         try {
            URL oUrl = ClassLoader.getSystemResource("client.policy");
            System.getProperties().put("java.security.policy",
                    oUrl.toExternalForm());
            System.setSecurityManager(new RMISecurityManager());
            context = new InitialContext(env);
         } catch (NamingException ne) {
            throw new ServiceException("Could not connect to server");
         }
      }

      public Object getInterface(RemoteBusinessService remoteBusinessService)
              throws ServiceException {
         try {
            return context.lookup(remoteBusinessService.name()
                    .replace("Service", "SessionBean/remote"));
         } catch (NamingException ne) {
            throw new ServiceException("Could not connect to server");
         }
      }

      public static Object getRemoteBusinessService(
              RemoteBusinessService remoteBusinessService)
              throws ServiceException {
         serviceLocator = (serviceLocator == = null) ?
                 new ServiceLocator() : serviceLocator;
         return serviceLocator.getInterface(remoteBusinessService);
      }
   }

Manager-Schnittstellen

Für den Umgang mit den Bean über das Remote-Interface, bewerkstelligen die Manager-Klassen. Die Schnittstelle Manager definiert die generischen CRUD-Operationen:

   public interface Manager <T> {

      public T create(T entity) throws CreateException;
      public T update(T entity) throws UpdateException;
      public void remove(T entity) throws RemoveException;
      public List <T> getByCriteria(Restriction criteria)
              throws FinderException;
   }

Die update-Methode gibt auch wie beispielsweise die create-Methode die (geänderte) Entität zurück. Grund dafür ist, dass man so auch für verbundene Entitäten, die möglicherweise im Zuge der Änderung auf Client-Seite neu angelegt und der Eltern-Entität hinzugefügt worden sind, die Ids erhält, die beim Persistieren der verbundenen Entitäten beim Update der Eltern-Entität generiert worden sind.

Die Manager-Klassen implementieren jeweils eine Schnittstelle namens <Name>Manager, welche die obige Schnittstelle mit dem entsprechenden EntityBean parametrisieren. (Theoretisch könnten Manager-Klassen gleich Manager mit dem jeweiligen EntityBean als Parameter implementieren. Da aber davon auszugehen ist, dass für jede Manager-Klasse in Zukunft spezielle Geschäftsmethoden hinzukommen werden, wird der Weg über separate Schnittstellen genommen, die hier zunächst noch leer sind, weil sie nur die Methoden aus der generischen Schnittstelle verwenden.)

   public interface [EntityBean]ManagerInterface
           extends ManagerInterface

Implementierung der Manager-Schnittstellen

Die [EntityBean]ManagerImplementation implementiert diese Schnittstellen dann so, dass der Aufruf einer Methode an die entsprechende Methode des Beans weiterdelegiert wird.

   public class [EntityBean]ManagerImplementation
           implements [EntityBean]Manager {

      private [EntityBean]Service [entityBean]Service;
      private static [EntityBean]ManagerImplementation [entityBean]Manager;

      private [EntityBean]ManagerImplementation() throws SystemException {
         [entityBean]]Service = ([EntityBean]Service)
                 ServiceLocator.getRemoteBusinessService(
         ServiceLocator.RemoteBusinessService.[EntityBean]Service);
      }

      public static [EntityBean]ManagerImplementation getInstance()
              throws SystemException {
         return ([entityBean]Manager == null) ?
                 new [EntityBean]ManagerImplementation() :
                 [entityBean]Manager;
      }

      public [EntityBean] create([EntityBean] [entityBean])
              throws CreateException {
         try {
            return [entityBean]Service.create([entityBean]);
         } catch(ServiceException serviceException) {
            throw new CreateException(serviceException);
         }
      }

      public List

ManagerFactory

Damit die restlichen Klassen im Presentation-Tier die [EntityBean]ManagerImplementation-Klassen nicht kennen müssen, wird mit der ManagerFactory, diese vor ihnen versteckt:

   public static [EntityBean]Manager get[EntityBean]Manager() {
      return [EntityBean]ManagerImplementation.getInstance();
   }

Sie sind somit nur noch von der Schnittstelle [EntityBean]Manager abhängig.

---

weiter zu 4.1.3 Definition der Schnittstelle zwischen Logik- und Persistenzschicht
zurück zu 4.1.1 Einrichtung der Entwicklungs- und Laufzeitumgebung
zurück zu 4.1 Implementierung der Referenzanwendung
zurück zu 4 Implementierung
zurück zu [FrontPage]