jBPM Standalone App com SWT

Question

De acordo com o whitepaper na página jBPM [1], JBMP pode ser facilmente usado em um aplicativo independente. No entanto, eu não poderia encontrar qualquer informação sobre como realmente fazer isso. Eu quero criar um aplicativo java simples (talvez com SWT), que apresenta um processo com jBPM. O utilizador deve em seguida ser capaz de modificar o comportamento de aplicações, através da modificação do diagrama jBPM. Para este efeito, eu também tenho que integrar alguns componentes eclipse eu acho .. alguma idéia como isso funciona?

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

Answer 1

Antes de começar, você pode querer também para ver se Roamflow atenda às suas necessidades, uma vez que parece ser um autônomo jBPM Eclipse / RCP com base espectador / editor.

Caso contrário, você deve saber como construir eclipse plug-ins, ou obter o livro que eu achei útil para a maioria das Eclipse Plugin / SWT necessidades de desenvolvimento, "Eclipse Imóvel comercial-qualidade Plug-ins", publicado pelo eclipse e Addison-Wesley. Além disso, eu não vou sentar e escrever um aplicativo de teste, você precisa entender os fundamentos de qualquer maneira.

1. Por autônomo eles correm média em qualquer JVM velho com as bibliotecas corretas. Ele precisa ser implantado em um recipiente J2EE, visto através da web, etc.

2. Olhe para o código-fonte do eclipse jBPM plug-in, uma vez que tem as características que você está procurando certo? Um SWT / eclipse base para que exibe jBPM. Isto inclui a verificação de pontos de extensão que jBPM pode instalar que você pode usar para construir o seu plug-in eclipse com rapidez. Por exemplo: O código de editor jBPM, aqui . Ou como serialize, aqui , re-uso.

3. Aqui está o SWT crítica / desenho, uma linha crítica é converter o jBPM para dentro e coisa SWT "g = new SWTGraphics (GC);". Este parece gerar uma imagem a partir de um modelo 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. Saiba a partir do plug-in do plugin.xml, src localizada aqui neste caso. Por exemplo, aqui é o jBPM adicionando-o de vista a eclipse:

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

   Este pode ser uma extensão que você deseja copiar como parece a levantar-se a 'visão'. Isso ajudará você a compreender como eles constroem as peças de seu aplicativo baseado eclipse. Você pode procurar por essas classes no seu espaço de trabalho e visualizar o código fonte se você instalou as versões de desenvolvedor sobre os plug-ins jBPM.

5. Decida se você precisa cortar para além das partes de aplicativos construídos como GMF (Graphical Modeling Framework) coisas, como o modelo, o comportamento da visão / diagrama e os diferentes editar / desenho de peças. Não mexa com isso, a menos que você também. No entanto, compreender GMF plug-ins ou procurando que os exemplos irá ajudá-lo a entender o que plug-in jBPM peças que você pode precisar de usar, especialmente se a edição é necessário.

6. Roll as peças em um plug-in, lembrando-se de reutilizar quais peças (plugins / pluglets) é possível a partir do projeto jBPM. Pode se de construir seu plugin eclipse como uma RCP ou Rich Client ... (Nota jBPM não têm actualmente uma RCP, por pós ) para que ele possa como um aplicativo eclipse independente para implantação mais fácil para as pessoas que não têm conhecimento da ferramenta eclipse.

Deixe-me saber se isso faz com que você se dirigiu para o caminho correto.

Answer 2

Sim, é possível executar o mecanismo de processo jBPM autônomo completamente, como um programa java simples. No contêiner J2EE necessário. Pelo menos este é o caso com jBPM 4.4

Quanto à exigência do código vai,

1. configurar o seu esquema de banco de dados jBPM
2. adicione as seguintes frascos da biblioteca distribuição jBPM ao classpath aplicações: antlr-runtime.jar antlr.jar dom4j.jar hibernação-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 os drivers JDBC necessários para a DB que você está usando.
3. e seus autônomos aparência de classe como este:

    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. Observe que, quando você estiver executando o mecanismo de processo de com no aplicativo SWT, reside o mecanismo de processo na mesma JVM como o SWT, para se certificar de que você alocar espaço suficiente.

Espero que isso ajude: -)