jBPM applicazione stand-alone con SWT

Question

Secondo il whitepaper sulla pagina jBPM [1], JBMP può essere facilmente utilizzato in un'applicazione stand-alone. Tuttavia, non sono riuscito a trovare tutte le informazioni su come fare in realtà questo. Voglio creare una semplice applicazione java (magari con SWT), che mostra un processo jBPM. L'utente dovrebbe quindi essere in grado di modificare il comportamento delle applicazioni, modificando il diagramma jBPM. A tal fine devo anche integrare alcuni componenti Eclipse penso .. tutte le idee come funziona?

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

Answer 1

Prima di iniziare, si potrebbe voler anche per vedere se Roamflow soddisfa le vostre esigenze in quanto sembra essere un autonomo jBPM Eclipse / RCP basato viewer / editor.

In caso contrario, si dovrebbe sapere come costruire plug-in Eclipse, o ottenere il libro che ho trovato utile per la maggior parte delle esigenze di sviluppo Plug-in Eclipse / SWT, "Eclipse costruzione commerciale-qualità plug-in", edito da Eclipse e Addison-Wesley. Inoltre, non ho intenzione di sedersi e si scrivere un applicazione di test, è necessario comprendere i fondamenti in ogni caso.

1. In stand-alone significano eseguito in qualsiasi vecchio JVM con le librerie giuste. Essa ha bisogno di essere implementato in un contenitore J2EE, visto attraverso il web, ecc.

2. guardare il codice sorgente per il jBPM plug-in Eclipse in quanto ha le caratteristiche che state cercando per la destra? Uno SWT / Eclipse based per che visualizza jBPM. Ciò comprende il controllo di punti di estensione che jBPM può installare che può essere utilizzato per costruire il tuo plug-in Eclipse con rapidamente. Per esempio: il codice editor di jBPM, qui . O come per serializzare, qui , il riutilizzo.

3. Questa è la critica SWT / disegno, una linea critica è la conversione del jBPM in e cosa SWT "g = new SWTGraphics (GC);". Questo sembra generare un'immagine da un modello jBPM.

   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. Impara dai plugin.xml del plug-in, situato src qui in questo caso. Ad esempio, qui è la jBPM aggiungendolo di vista di eclissare:

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

   Questo può essere un'estensione che si desidera copiare come sembra di stare in piedi la "vista". Questo vi aiuterà a capire come si costruiscono i pezzi del loro app basato su Eclipse. È possibile cercare queste classi nel vostro spazio di lavoro e visualizzare il codice sorgente se avete installato le versioni sviluppatore del plug-in jBPM.

5. Decidere se è necessario incidere a parte le parti app costruito come GMF (Graphical Modeling Framework) roba, come il modello, il comportamento della visualizzazione / diagramma e la diversa modificare / disegno parti. Non si scherza con questo a meno che non si dispone di troppo. Tuttavia, la comprensione GMF plug-in o in cerca che gli esempi vi aiuterà a capire ciò che jBPM plug-in pezzi che si potrebbe aver bisogno di usare, soprattutto se è necessaria la modifica.

6. Stendere i pezzi in un plug-in, ricordando di riutilizzare quali pezzi (plugins / pluglets) è possibile dal progetto jBPM. Può sicuri di costruire il tuo plugin di Eclipse come un RCP o Rich Client ... (Nota jBPM attualmente non ha un RCP, per posta ) in modo che possa come applicazione stand-alone eclissi per una più facile distribuzione per le persone che non hanno conoscenze strumento di eclisse.

Fatemi sapere se questo diventa sei diretto verso il basso il percorso corretto.

Answer 2

Sì, è possibile far funzionare il motore processo jBPM completamente autonomo, come un semplice programma Java. Nessun contenitore J2EE necessaria. Almeno questo è il caso con jBPM 4.4

Per quanto riguarda il codice requisito va,

1. schema di configurazione del database jbpm
2. aggiungere le seguenti vasi dalla libreria di distribuzione jBPM alle applicazioni 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 E i driver JDBC necessari per il DB che si sta utilizzando.
3. e la classe standalone aspetto:

    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. Si noti che quando si esegue il motore processo dal con l'applicazione SWT, il motore processo risiede sulla stessa JVM come lo SWT, in modo da assicurarsi che si alloca spazio sufficiente.

Spero che questo aiuti: -)