jBPM Standalone-App mit SWT

Question

Nach dem White Paper auf der jBPM Seite [1], kann JBMP leicht in einer Standalone-Anwendung verwendet werden. Allerdings konnte ich keine Informationen über finden, wie man dies tatsächlich tun. Ich möchte eine einfache Java-Anwendung (vielleicht mit SWT) zu schaffen, die einen Prozess mit jBPM anzeigt. Der Benutzer sollte dann in der Lage sein, die Anwendungen Verhalten zu ändern, indem Sie das jBPM Diagramm ändern. Zu diesem Zweck .. Ich denke, einige Eclipse-Komponenten integrieren muss ich auch Ideen, wie das funktioniert?

[1] http://www.jboss.com/pdf/jbpm_whitepaper.pdf

Answer 1

Bevor Sie beginnen, können Sie auch sehen, ob Roamflow Ihre Bedürfnisse, wie es erfüllt scheint eine eigenständige jBPM Eclipse / RCP basierten Viewer / Editor zu sein.

Ansonsten sollten Sie wissen, wie Eclipse-Plug-in bauen, oder das Buch erhalten ich nützlich für die meisten Eclipse-Plugin / SWT Entwicklung Bedürfnisse gefunden „Eclipse-Gebäude kommerzielle Qualität Plug-in“, veröffentlicht von Eclipse und Addison-Wesley. Auch ich werde sich nicht hin und schreiben Sie eine Test-App, müssen Sie die Grundlagen verstehen, irgendwie.

1. Mit dem Stand-alone sie in jedem alten JVM mit den richtigen Bibliotheken bedeuten laufen. Es muss in einem J2EE-Container eingesetzt werden, durch die Bahn gesehen, etc.

2. Schauen Sie sich den Quellcode für die jBPM Eclipse-Plug-in, wie es die Funktionen, die Sie für richtig suchen? Ein SWT / Eclipse basierte, dass zeigt jBPM. Dazu gehören für Erweiterungspunkte überprüft, die jBPM installieren können, die Sie Ihre Eclipse-Plug-in mit schnell erstellen können. Zum Beispiel: Der Editor Code jBPM, hier . Oder wie Serialisierung, hier , wieder zu verwenden.

3. Hier ist die kritische SWT / Zeichnung, eine kritische Linie ist die jBPM in und SWT Sache Umwandlung "g = new SWTGraphics (gc);". Dies scheint ein Bild von einem jBPM Modell zu erzeugen.

   protected void writeImage() {           
   SWTGraphics g = null;
   GC gc = null;
   Image image = null;
   LayerManager lm = (LayerManager)getGraphicalViewer().getEditPartRegistry().get(LayerManager.ID);
   IFigure figure = lm.getLayer(LayerConstants.PRINTABLE_LAYERS);
   
   try {
       Rectangle r = figure.getBounds();
       image = new Image(Display.getDefault(), r.width, r.height);
       gc = new GC(image);
       g = new SWTGraphics(gc);
       g.translate(r.x * -1, r.y * -1);
       figure.paint(g);
       ImageLoader imageLoader = new ImageLoader();
       imageLoader.data = new ImageData[] {image.getImageData()};
       imageLoader.save(getImageSavePath(), SWT.IMAGE_JPEG);
       refreshProcessFolder();
   
   } finally {
       //SNIP
   }
   }
   

4. Lernen von den Plug-Ins plugin.xml, src befindet hier in diesem Fall. Zum Beispiel, hier ist die jBPM es nach Ansicht Hinzufügen zu verdunkeln:

   point="org.eclipse.ui.views" ... view class="org.jboss.tools.flow.jpdl4.view.DetailsView"...
   

   Dieses eine Erweiterung sein können Sie kopieren möchten, wie es die aufstehen scheint "Ansicht". Dies wird Ihnen helfen zu verstehen, wie sie die Stücke ihrer Eclipse-basierte Anwendung konstruieren. Sie können für diese Klassen in Ihrem Arbeitsbereich suchen und den Quellcode, wenn Sie die Entwickler-Versionen auf der JBPM Plug-In installiert.

5. Entscheiden Sie, ob Sie die App Teile gebaut als GMF (Graphical Modeling Framework) Sachen auseinander schlagen müssen, wie das Modell, das Verhalten der Ansicht / Diagramm und die verschiedenen Bearbeitungs / Zeichnungsteile. Verwirren Sie nicht mit diesem, wenn Sie zu haben. Allerdings versteht GMF-Plug-In oder auf der Suche, dass die Beispiele helfen Ihnen verstehen, was jBPM Plug-in Stücken, die Sie möglicherweise verwenden müssen, vor allem, wenn die Bearbeitung erforderlich ist.

6. Rollen Sie die Stücke in ein Plug-in, um die Wiederverwendung zu erinnern, was Stücke (plugins / pluglets) Sie aus dem jBPM Projekt kann. Kann sicher Ihre Eclipse-Plugin als RCP oder Rich-Client zu bauen ... (Anmerkung jBPM momentan keine RCP hat, per post ), so dass es als eclipse-Standalone-Anwendung für eine einfachere Bereitstellung für Menschen, die nicht eclipse-Tool Wissen verfügen.

Lassen Sie mich wissen, ob dies bekommt man den richtigen Pfad Weg nach unten.

Answer 2

Ja, es ist möglich, die jbpm Process Engine völlig eigenständige, als ein einfaches Java-Programm auszuführen. Keine J2EE-Container benötigt. Zumindest ist dies der Fall mit jBPM 4.4

Was der Code Anforderung geht,

1. setup Ihre jbpm Datenbank-Schema
2. fügen Sie die folgenden Gläser aus der jbpm Verteilung Bibliothek auf die Anwendungen Classpath: antlr-runtime.jar antlr.jar dom4j.jar Hibernate-core.jar javassist.jar jbpm.jar slf4j-api.jar slf4j-jdk14.jar slf4j-log4j12.jar commons-collections.jar jta.jar juel-api.jar juel-engine.jar juel-impl.jar mail.jar Und die notwendigen JDBC-Treiber für die DB, die Sie verwenden.
3. und Ihre Standalone-Klasse sieht wie folgt aus:

    package test.ayusman;

    import java.util.HashMap;
    import java.util.Map;

    import org.jbpm.api.Configuration;
    import org.jbpm.api.ExecutionService;
    import org.jbpm.api.ProcessEngine;
    import org.jbpm.api.ProcessInstance;
    import org.jbpm.api.RepositoryService;

    public class ProcessDeployer {

        // Create a process engine that can be used for all other work...
        // ProcessEngine is starting point for all other application.
        private static ProcessEngine jbpmProcessEngine = new Configuration()
                .setResource("jbpm.cfg.xml").buildProcessEngine();
        // private static Logger logger = Logger.getLogger(JBPMDao.class);

        private static RepositoryService repositoryService = null;
        private static ExecutionService executionService = null;
        private static ProcessInstance pi = null;
        private static String processInstanceState;
        private static String processInstanceId;


        public static void main(String[] args) {
            try {

                ProcessDeployer ejm = new ProcessDeployer();

                //Start the process...
                ejm.startProcess();

                //Analyze process... just a small fancy method
                ejm.analyzeProcess();


            } catch (Exception e) {
                e.printStackTrace();
            }

        }// End of main()


        void startProcess() throws Exception
        {

            repositoryService = jbpmProcessEngine.getRepositoryService();
            executionService =  jbpmProcessEngine.getExecutionService();

            //NOTE: The example assumes that the process definition file name is: your_process.jpdl.xml
            processInstanceId = repositoryService.createDeployment().addResourceFromClasspath("your_process.jpdl.xml").deploy();             

            //NOTE: The jpdl file has key name as "Java"
            pi = executionService.startProcessInstanceByKey("Java");  

            System.out.println("Obtained processInstanceId is: "+processInstanceId);             
        }

        void analyzeProcess() throws Exception
        {
            processInstanceState = pi.getState();
            System.out.println("processInstanceState is: "+processInstanceState);
            System.out.println("processInstanceId is: "+processInstanceId);
        }


    }// End of class ProcessDeployer

1. Beachten Sie, dass, wenn Sie den Prozess-Engine von mit der SWT-Anwendung ausgeführt wird, der Prozess-Engine auf der gleichen JVM wie der SWT befindet, so stellen Sie sicher, dass Sie genügend Platz zuweisen.

Hope, das hilft: -)