Java-Code zum Erfassen von Details der Codegenerierung schreiben

Sie können jetzt Java™-Code schreiben, um einen Bericht oder eine andere Antwort auf Ereignisse zur Generierungszeit zu erzeugen.

Das Produkt stellt folgenden Code im Plug-in mit dem Namen 'com.ibm.etools.egl' im Paket mit dem Namen 'com.ibm.etools.egl.genresults' zur Verfügung:
Die Produktklassen rufen die folgenden Methoden in Ihrem Listener auf:
Hier sehen Sie die Reihenfolge der Aufrufe, die während einer Generierung vorkommen können:
generationStarted
   phaseStarted
      warning
      generatingPart
         createdArtifact
         warning
         createdArtifact
         createdArtifact
      generatingPart
         warning
      generatingPart
         createdArtifact
         information
   phaseFinished
   phaseStarted
      generatingPart
         createdArtifact
      generatingPart
      generatingPart
         createdArtifact
   phaseFinished
generationFinished
Im Allgemeinen gehen Sie wie folgt vor:
  1. Schreiben Sie ein Klasse, um die Schnittstelle GenerationResultsListener zu implementieren, die im folgenden Abschnitt beschrieben ist: Schnittstellendetails.
  2. Erstellen Sie eine Instanz der Klasse, um den Listener zu erstellen. Dann registrieren Sie den Listener beim EGL-Generator. Beispiel:
    MyListenerClass myListenerObject = new MyListenerClass();
    com.ibm.etools.egl.genresults.GenerationResultsServer.
       getInstance().addListener(myListenerObject);

    Die zweite Anweisung hat die folgenden Auswirkungen:

    1. Das Objekt 'GenerationResultsServer' wird abgerufen, indem die statische Methode 'getInstance' dieser Klasse aufgerufen wird.
    2. Der Listener mit dem Namen myListenerObject wird an die Methode 'addListener' des Objekts 'GenerationResultsServer' übergeben.

    Sie können die Registrierung des Listeners zurücknehmen, indem Sie ihn an die Methode 'removeListener' des Objekts 'GenerationResultsServer' übergeben.

Einzelheiten zur Task finden Sie im entsprechenden Abschnitt:

Interaktion mit der Workbench

Wenn Sie mit der Workbench interagieren, müssen Sie ein Plug-in erstellen, das einen Listener für die Generierungsergebnisse registriert. Zusätzlich müssen Sie ein Standardverhalten des Eclipse-Laufzeitcodes überschreiben, das in der Regel ein Plug-in nur dann lädt, wenn das Plug-in von einem zuvor geladenen Plug-in benötigt wird.

Gehen Sie folgendermaßen vor:
  1. Stellen Sie den Code in ein Plug-in, aktualisieren Sie die Datei MANIFEST.MF, so dass Ihr Plug-in von folgenden Plug-ins abhängt:
    • com.ibm.etools.egl, das sich im Produktinstallationsverzeichnis befindet.
    • org.eclipse.ui.
  2. Erstellt eine Klasse, die 'org.eclipse.ui.IStartup' implementiert. Eine Java-Schnittstelle, die nur die Methode 'earlyStartup' aufweist. Ihre Implementierung von 'earlyStartup' registriert Ihr Listenerobjekt wie in dem folgenden Beispiel:
    package com.ibm.test.egl.genresults.listener;
    
    import org.eclipse.ui.IStartup;
    import com.ibm.etools.egl.genresults.GenerationResultsServer;
    
    public class StartupClass implements IStartup
    {
       public void earlyStartup()
       {
          GenerationResultsServer.getInstance().addListener(new TestListener(true));
       }
    }
  3. Schließen Sie folgenden Eintrag in die Datei 'plugin.xml' ein:
    <extension point="org.eclipse.ui.startup">
       <startup class="com.ibm.test.egl.genresults.listener.StartupClass"/>
    </extension>
  4. Exportieren Sie das Plug-in folgendermaßen in eine JAR-Datei:
    1. Klicken Sie auf Datei > Export. Die Exportseite wird geöffnet.
    2. Erweitern Sie unter Exportziel auswählen die Option Plug-in-Entwicklung und klicken Sie dann auf Implementierbare Plug-ins und Fragmente. Die Seite mit implementierbaren Plug-ins und Fragmenten wird geöffnet.
    3. Auf der Registerkarte 'Ziele' geben Sie in der Mitte der Seite den Eclipse-Ordner 'dropins' an. Beispiel C:\Program Files\IBM\SDP80\dropins.
    4. Klicken Sie auf der Registerkarte 'Optionen', um sicherzustellen, dass Paket-Plug-ins als einzelne JAR-Archive ausgewählt ist.
    5. Klicken Sie auf Fertig stellen. Die JAR-Datei befindet sich im Ordner 'dropins' in einem Ordner mit Plug-ins.
    6. Öffnen Sie Windows Explorer und wechseln Sie zum Ordner mit den Plug-ins.
    7. Verschieben Sie die neue JAR-Datei, damit diese sich direkt im Ordner 'dropins' befindet.
    8. Löschen Sie den leeren Ordner für Plug-ins.

Workbenchstapelschnittstelle (EGLCMD) verwenden

Wenn Sie die Workbenchstapelschnittstelle (EGLCMD) verwenden, führen Sie folgende Schritte aus:
  1. Erstellen Sie ein Plug-in.
  2. Aktualisieren Sie die Datei MANIFEST.MF, damit Ihr Plug-in von dem Plug-in 'com.ibm.etools.egl' abhängt, in dem sich das Produktinstallationsverzeichnis befindet.
  3. Stellen Sie sicher, dass Ihr Plug-in auf den Erweiterungspunkt mit dem Namen 'org.eclipse.core.runtime.applications' verweist, wie dies in folgendem Beispielcode in der Datei 'plugin.xml' der Fall ist:
    <extension id="TestCMD" point="org.eclipse.core.runtime.applications">
       <application>
          <run class="com.ibm.test.egl.genresults.listener.TestCMD"></run>
       </application>
    </extension>

    Der Wert des Attributs id kann ein beliebiger Wert sein, den Sie zuordnen.

    Der Wert des Attributs class gibt eine Klasse an, die die Schnittstelle 'Eclipse IApplication' implementiert, das Objekt 'GenerationResultsListener' registriert und die Befehlszeilenargumente an die Methode 'com.ibm.etools.edt.core.ide.batch.EGLCMD.process' übergibt. Hier folge ein Beispiel für eine solche Klasse:
    package com.ibm.test.egl.genresults.listener;
    
    import org.eclipse.equinox.app.IApplication;
    import org.eclipse.equinox.app.IApplicationContext;
    import com.ibm.etools.edt.core.ide.batch.EGLCMD;
    import com.ibm.etools.egl.genresults.GenerationResultsServer;
    
    public class TestCMD implements IApplication
    {
       @Override
       public Object start( IApplicationContext appContext ) throws Exception
       {
          // Register a GenerationResultsListener.
          GenerationResultsServer.getInstance().addListener(new TestListener(true));
    
    	      // Get the command-line arguments.
          String[] args = (String[])appContext.getArguments().
                                    get( IApplicationContext.APPLICATION_ARGS );
    
          // Pass the command-line arguments to EGLCMD.
          EGLCMD.process( args );
          return null;
       }
    
       @Override
       public void stop()
       {}
    }
  4. Exportieren Sie das Plug-in wie folgt in eine JAR-Datei:
    1. Klicken Sie auf File > Export. Die Seite für den Export wird geöffnet.
    2. Erweitern Sie unter Exportziel auswählen die Option Plug-in-Entwicklung und klicken Sie dann auf Implementierbare Plug-ins und Fragmente. Die Seite mit implementierbaren Plug-ins und Fragmenten wird geöffnet.
    3. Auf der Registerkarte 'Ziele' geben Sie in der Mitte der Seite den Eclipse-Ordner 'dropins' an. Beispiel C:\Program Files\IBM\SDP80\dropins.
    4. Klicken Sie auf der Registerkarte 'Optionen', um sicherzustellen, dass Paket-Plug-ins als einzelne JAR-Archive ausgewählt ist.
    5. Klicken Sie auf Fertig stellen. Die JAR-Datei befindet sich im Ordner 'dropins' in einem Ordner mit Plug-ins.
    6. Öffnen Sie Windows Explorer und wechseln Sie zum Ordner mit den Plug-ins.
    7. Verschieben Sie die neue JAR-Datei, damit diese sich direkt im Ordner 'dropins' befindet.
    8. Löschen Sie den leeren Ordner für Plug-ins.
  5. Stellen Sie sicher, dass Ihr Java-Klassenpfad Zugriff auf die folgenden JAR-Dateien bietet:
    • org.eclipse.equinox.launcher_version.jar, die sich in folgendem Verzeichnis befindet:
      installationDir\sdp70\plugins
      installationDir
      Das Produktinstallationsverzeichnis wie beispielsweise C:\Program Files\IBM.

      Bitte beachten Sie, dass dieses Verzeichnis ein gemeinsam genutztes Verzeichnis ist.

    • com.ibm.etools.edt.core.ide.version, das sich in folgendem Verzeichnis befindet:
      installationDir\sdp70shared\plugins
      installationDir
      Das Produktinstallationsverzeichnis wie beispielsweise C:\Program Files\IBM.
  6. Rufen Sie die Anwendung wie folgt auf:
    java org.eclipse.core.launcher.Main -application 
       test.genresults.listener.TestCMD argument_list

    Anstelle von argument_list geben Sie die Argumente an, die im Referenzabschnitt "EGLCMD" dokumentiert sind.

    In diesem Beispiel ist test.genresults.listener der Name des Plug-ins und TestCMD ist der Wert der id-Attribute im Element <extension> in 'plugin.xml'.

EGL-Software-Development-Kit (EGLSDK) verwenden

Wenn Sie das EGL-Software-Development-Kit (EGLSDK) verwenden, müssen Sie Ihre eigene Java-Klasse schreiben und anstelle des EGLSDK-Befehls ausführen:
  1. Legen Sie Klassenpfade (classpaths) so fest, dass die Datei 'eglbatchgen.jar' verfügbar ist:
    • Wenn Sie Ihren Code entwickeln, muss die Datei 'eglbatchgen.jar' sich im Klassenpfad des Java-Compilers befinden.
    • Wenn Sie den Code ausführen, muss die Datei 'eglbatchgen.jar' sich in Ihrer Systemvariable CLASSPATH befinden.

    Einzelheiten zur Position der Datei 'eglbatchgen.jar' und anderer Voraussetzungen finden Sie unter "Generierung mit dem EGL-Software-Development-Kit (SDK)".

  2. Registrieren Sie ein Objekt vom Typ 'GenerationResultsListener' und erstellen Sie ein EGLSDK-Objekt wie im folgenden Beispiel:
    package example;
    
    import com.ibm.etools.egl.genresults.GenerationResultsServer;
    import com.ibm.etools.egl.util.EGLSDK;
    
    public class EGLSDKWithListener
    {
       public static void main( String[] args )
       {
          MyListenerClass myListenerObject = new MyListenerClass();
          GenerationResultsServer.getInstance().addListener(myListenerObject);
          EGLSDK sdk = new EGLSDK();
          sdk.process( args );
       }
    }
  3. Führen Sie die Klasse anstelle des Befehls EGLSDK aus und verwenden Sie dabei dieselben Argumente wie beim Aufruf des Befehls EGLSDK.
    Es folgenden die Details zur Klasse EGLSDK, die Sie instanziieren:
    public class EGLSDK
    {
       /* Creates an EGLSDK object that does not print messages to System.out. */
       public EGLSDK();
    
       /* Creates an EGLSDK object that might print messages to System.out.
        *
        * @param printMessages   true if messages should be printed to System.out.
       */
       public EGLSDK(boolean printMessages);
       
       /*
        * Generates EGL.
        *
        * @param args are the EGLSDK command-line arguments.
       */
       public void process(String[] args);
       
       /*
        * Returns the messages from the most recent call of process(String[]).
        *
        * @return the messages.  The array may be empty but will not be null.
       */
       public Message[] getMessages();
    
       /*
        * Indicates if there were any errors during generation.
        *
        * @return true if any errors occurred
        *              in the most recent call of process(String[]).
        */
        public boolean generationFailed();
    }
    Hier wird eine Nachrichtenklasse in der Klasse EGLSDK referenziert:
    package com.ibm.etools.egl.util;
    
    public class Message
    {
       public static final int ERROR_MESSAGE = 1;
       public static final int WARNING_MESSAGE = 2;
       public static final int INFORMATIONAL_MESSAGE = 3;
    
       public String getText();
       public int getSeverity();
       public boolean isError();
    }

Schnittstellendetails

Hier finden Sie die Schnittstelle 'GenerationResultsListener':
public interface GenerationResultsListener
{
   // Called when generation starts
   void generationStarted( GenerationStartedEvent gse );

   // Called when generation ends
   void generationFinished();

   // Called when a generation phase starts
   void phaseStarted( GenerationPhase gp );

   // Called when a generation phase ends
   void phaseFinished();

   // Called when generation of a part begins
   void generatingPart( PartGenerationEvent event );

   // Called after one generated output is created for the part
   // during the most recent event of type PartGenerationEvent
   void createdArtifact( ArtifactCreatedEvent event );    

   // Called when an error message is issued
   void error( MessageEvent event );
    
   // Called when a warning message is issued.
   void warning( MessageEvent event );
    
   // Called when an informational message is issued.
   void information( MessageEvent event );
}
Hier sind weitere Java-Schnittstellen:
public interface GenerationStartedEvent
{
   /**
    * Returns true if generation is running in the workbench or EGLCMD,
    * false if generation is running in EGLSDK.
    */
   boolean generatingInEclipse();
   
   /**
    * Returns the path to the Eclipse workspace if generation is running
    * in the workbench or EGLCMD.  Returns the eglpath value if generation 
    * is running in EGLSDK.
    */
   String getWorkPath();
}

public interface GenerationPhase
{
   /**
    * Returns a Part object (explained later) 
    * that gives details on the build descriptor.
   */
   Part getPart();
}

public interface PartGenerationEvent
{
   /**
    * Returns a Part object that gives details on the part being generated.
    */
   Part getPart();
}

public interface ArtifactCreatedEvent
{
   /**
    * Returns the path to a file generated from the part.  
    * The path is relative to the Eclipse workspace if generation 
    * is running in the workbench or EGLCMD and if the artifact was generated
    * into a project named by the genProject option in the build descriptor.  
    *
    * In other cases, the path is an absolute path in the file system.
    */
   String getFileName();

   /**
    * Returns the absolute path to a file generated from the part.
    * (The method returns the same value as getFileName if generation 
    * is running in EGLSDK or if the artifact was not generated into a project.)
    */
   String getAbsolutePath();
}
public interface Part
{
   static final int BUILD_DESCRIPTOR = 1;
   static final int DEPLOYMENT_DESCRIPTOR = 2;
   static final int PROGRAM = 3;
   static final int LIBRARY = 4;
   static final int HANDLER = 5;
   static final int RECORD = 6;
   static final int DATA_TABLE = 7;
   static final int FORM_GROUP = 8;
   static final int SERVICE = 9;
   static final int DELEGATE = 10;
    
   /**
    * 
    * Returns the constant identifying the kind of part 
    * that has been generated.
    */
   int getKind();

   /**
    * Returns the name of the part.
    */
   String getName();
   
   /**
    * Returns the package name of the part. 
    * If the part is in the default package, an empty string is returned.  
    * If the part represents a build descriptor or deployment descriptor, 
    * the method returns null.
    */
   String getPackageName();

   /**
    * Returns the path to the EGL file for the part. The path is relative to the 
    * Eclipse workspace if generation is running in the workbench or EGLCMD. The path
    * is an absolute path in the file system if generation is running in EGLSDK.
    */
   String getFileName();

   /**
    * Returns the absolute path to the EGL file for the part.  
    * (This method returns the same value as getFileName 
    * if generation is running in EGLSDK.)
    */
   String getAbsolutePath();
}

public interface MessageEvent
{
   static final int ERROR = 1;
   static final int WARNING = 2;
   static final int INFORMATION = 3;
    
   /**
    * Returns INFORMATION, WARNING, or ERROR.
    */
   int getKind();

   /**
    * Returns the text of the message.
    */
   String getText();
   
   /**
    * Returns the ID of the message.
    */    
   String getID();
}

Feedback