jBPM App autonome avec SWT

Question

Selon le livre blanc sur la page jBPM [1], JBMP peut être facilement utilisé dans une application autonome. Cependant, je ne pouvais pas trouver aucune information sur la façon de faire réellement cela. Je veux créer une application simple java (peut-être avec SWT), qui affiche un processus avec jBPM. L'utilisateur doit ensuite être en mesure de modifier le comportement des applications, en modifiant le diagramme jBPM. A cet effet, je dois aussi intégrer certains composants Eclipse, je pense .. toutes les idées comment cela fonctionne?

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

Answer 1

Avant de commencer, vous pouvez également voir si Roamflow répond à vos besoins comme semble être un spectateur / éditeur basé sur Eclipse autonome jBPM / RCP.

Sinon, vous devez savoir comment construire Eclipse plug-ins, ou obtenir le livre que je trouve utile pour la plupart des besoins de développement plugin Eclipse / SWT, "Eclipse Commercial Building-qualité Plug-ins", publié par Eclipse et Addison-Wesley. Aussi, je ne vais pas vous asseoir et écrire une application de test, vous devez comprendre les fondements de toute façon.

1. Par autonome ils veulent dire courir dans une ancienne machine virtuelle Java avec les bonnes librairies. Il n'a pas besoin d'être déployé dans un conteneur J2EE, vu à travers le web, etc.

2. Regardez le code source pour la jBPM plug-in Eclipse car il a les caractéristiques que vous recherchez à droite? Un SWT / éclipse à base de jBPM qui affiche. Cela inclut la vérification des points d'extension qui jBPM peut installer que vous pouvez utiliser pour construire votre plug-in Eclipse rapidement. Par exemple: Le code de l'éditeur jBPM, ici . Ou comment sérialiser, ici , la réutilisation.

3. Voici le SWT / dessin critique, une ligne critique est de convertir le jBPM dans et chose SWT "g = new SWTGraphics (GC);". Cela semble générer une image à partir d'un modèle 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. Apprendre de la plugin.xml du plug-in, situé src ici dans ce cas. Par exemple, voici le jBPM ajouter de vue éclipser:

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

   Cette peut être une extension que vous souhaitez copier comme il semble résister à la "vue". Cela vous aidera à comprendre comment ils construisent les morceaux de leur application à base d'éclipse. Vous pouvez rechercher ces classes dans votre espace de travail et afficher le code source si vous avez installé les versions de développement sur les plug-ins jBPM.

5. Décider si vous avez besoin de pirater les pièces en dehors d'applications intégrées comme substance FMV (cadre graphique de modélisation), comme le modèle, le comportement de la vue / diagramme et les différentes parties modifier / dessin. Ne jouez pas avec cela, sauf si vous avez trop. Cependant, la compréhension des plug-ins FMV ou à la recherche que les exemples vous aideront à comprendre ce plug-in pièces jBPM vous pourriez avoir besoin d'utiliser, surtout si l'édition est nécessaire.

6. Roulez les morceaux dans un plug-in, ne pas oublier de réutiliser ce que les pièces (plugins / pluglets), vous pouvez du projet jBPM. Peut-vous pour construire votre plugin Eclipse comme RCP ou Rich Client ... (Note jBPM ne dispose pas actuellement d'une RCP, par après ) afin qu'il puisse comme une application autonome Eclipse pour le déploiement plus facile aux personnes qui n'ont pas éclipse la connaissance de l'outil.

Laissez-moi savoir si cela vous permet de vous dirigez vers sur le bon chemin.

Answer 2

Oui il est possible de faire tourner le moteur de processus jBPM complètement autonome, comme un simple programme java. Aucun conteneur J2EE nécessaire. c'est au moins le cas avec jBPM 4.4

En ce qui concerne l'exigence de code va,

1. configurer votre schéma de base de données jBPM
2. ajouter les pots suivants de la bibliothèque de distribution de jBPM aux applications 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 Et les pilotes JDBC nécessaires à la DB que vous utilisez.
3. et votre classe autonome ressemble à ceci:

    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. Notez que lorsque vous utilisez le moteur de processus à partir avec dans l'application SWT, le moteur de processus réside sur la même machine virtuelle Java que le SWT, alors assurez-vous que vous allouez suffisamment d'espace.

Hope this helps: -)