Activiti7整合Springboot使用记录

<dependency>

     <groupid>org.activiti</groupid>

     <artifactid>activiti-spring-boot-starter</artifactid>

     <version> 7.1 . 0 .m6</version>

</dependency>

package cn.gzsendi.activitidemotest.config;

import java.util.arrays;

import java.util.list;

import java.util.stream.collectors;

import org.slf4j.logger;

import org.slf4j.loggerfactory;

import org.springframework.context.annotation.bean;

import org.springframework.context.annotation.configuration;

import org.springframework.security.core.authority.simplegrantedauthority;

import org.springframework.security.core.userdetails.user;

import org.springframework.security.core.userdetails.userdetailsservice;

import org.springframework.security.crypto.bcrypt.bcryptpasswordencoder;

import org.springframework.security.crypto.password.passwordencoder;

import org.springframework.security.provisioning.inmemoryuserdetailsmanager;

@configuration

public class activiticonfiguration {

     private logger logger = loggerfactory.getlogger(activiticonfiguration. class );

     @bean (name = "userdetailsservice" )

     public userdetailsservice myuserdetailsservice() {

         inmemoryuserdetailsmanager inmemoryuserdetailsmanager = new inmemoryuserdetailsmanager();

         //用户

         string[][] usersgroupsandroles = {

                 { "hefy" , "123456" , "role_activiti_user" },

                 { "liujh" , "123456" , "role_activiti_admin" },

                 { "liuky" , "123456" , "role_activiti_user" },

                 { "admin" , "123456" , "role_activiti_admin" },

         };

         for (string[] user : usersgroupsandroles) {

             list<string> authoritiesstrings = arrays.aslist(arrays.copyofrange(user, 2 , user.length));

             logger.info( "> registering new user: " + user[ 0 ] + " with the following authorities[" + authoritiesstrings + "]" );

             inmemoryuserdetailsmanager.createuser( new user(user[ 0 ], passwordencoder().encode(user[ 1 ]),

                     authoritiesstrings.stream().map(s -> new simplegrantedauthority(s)).collect(collectors.tolist())));

         }

         return inmemoryuserdetailsmanager;

     }

     @bean

     public passwordencoder passwordencoder() {

         return new bcryptpasswordencoder();

     }

}

package cn.gzsendi.activitidemotest.utils;

import java.util.collection;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.beans.factory.annotation.qualifier;

import org.springframework.security.core.authentication;

import org.springframework.security.core.grantedauthority;

import org.springframework.security.core.context.securitycontextholder;

import org.springframework.security.core.context.securitycontextimpl;

import org.springframework.security.core.userdetails.userdetails;

import org.springframework.security.core.userdetails.userdetailsservice;

import org.springframework.stereotype测试数据ponent;

import javax.annotation.resource;

@component

public class securityutil {

     @autowired

     @qualifier ( "userdetailsservice" )

     private userdetailsservice userdetailsservice;

     public void loginas(string username) {

         userdetails user = userdetailsservice.loaduserbyusername(username);

         if (user == null ) {

             throw new illegalstateexception( "user " + username + " doesn't exist, please provide a valid user" );

         }

         securitycontextholder.setcontext( new securitycontextimpl( new authentication() {

             @override

             public collection<? extends grantedauthority> getauthorities() {

                 return user.getauthorities();

             }

             @override

             public object getcredentials() {

                 return user.getpassword();

             }

             @override

             public object getdetails() {

                 return user;

             }

             @override

             public object getprincipal() {

                 return user;

             }

             @override

             public boolean isauthenticated() {

                 return true ;

             }

             @override

             public void setauthenticated( boolean isauthenticated) throws illegalargumentexception {

             }

             @override

             public string getname() {

                 return user.getusername();

             }

         }));

         org.activiti.engine.impl.identity.authentication.setauthenticateduserid(username);

     }

}

server.port= 8080

server.servlet.context-path=/activitidemotest

spring.datasource.driver- class -name=com.mysql.cj.jdbc.driver

spring.datasource.url=jdbc:mysql: //localhost:3306/activitidemo?usessl=false&useunicode=true&characterencoding=utf8&servertimezone=gmt%2b8&allowmultiqueries=true

spring.datasource.username=root

spring.datasource.password= 123456

spring.activiti.database-schema-update= true

spring.activiti.db-history-used= true

spring.activiti.history-level=full

spring.activiti.check-process-definitions= false

spring.activiti.deployment-mode=never-fail

spring.activiti.process-definition-location-prefix=classpath:/process/

package cn.gzsendi.activitidemotest;

/**

  * created by jxlhl on 2021/8/18.

  */

import org.activiti.engine.repositoryservice;

import org.activiti.engine.repository.deployment;

import org.activiti.engine.repository.deploymentbuilder;

import org.junit.test;

import org.junit.runner.runwith;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.boot.test.context.springboottest;

import org.springframework.test.context.junit4.springrunner;

@runwith (springrunner. class )

@springboottest

public class springbootjunittest {

     //得到repositoryservice实例

     @autowired

     private repositoryservice repositoryservice;

     //0.流程部署，单个文件部署方式

     @test

     public void testdeployment(){

         //使用repositoryservice进行部署

         deploymentbuilder builder = repositoryservice.createdeployment();

         builder.addclasspathresource( "process/process1.bpmn20.xml" );

         builder.addclasspathresource( "process/process1.jpg" );

         builder.name( "first_activiti_process" );

         deployment deployment = builder.deploy();

         //输出部署信息

         system.out.println( "流程部署id：" + deployment.getid());

         system.out.println( "流程部署名称：" + deployment.getname());

         //流程部署id：125098e1-ffd9-11eb-8847-02004c4f4f50

         //流程部署名称：first_activiti_process

     }

}

//1.流程实例启动

   @test

   public void teststartprocess(){

       //根据流程定义id启动流程

       processinstance processinstance = runtimeservice.startprocessinstancebykey( "myprocess_1" );

       //输出实例信息

       system.out.println( "流程定义id：" + processinstance.getprocessdefinitionid());

       system.out.println( "流程实例id：" + processinstance.getid());

       system.out.println( "当前活动id：" + processinstance.getactivityid());

       //流程定义id：myprocess_1:1:12702ed4-ffd9-11eb-8847-02004c4f4f50

       //流程实例id：a9b162aa-ffda-11eb-bad1-02004c4f4f50

       //当前活动id：null

   }

act_hi_actinst 流程实例执行历史

act_hi_identitylink 流程的参与用户历史信息

act_hi_procinst 流程实例历史信息

act_hi_taskinst 流程任务历史信息

act_ru_execution 流程执行信息

act_ru_identitylink 流程的参与用户信息

act_ru_task 任务信息

//2.任务查询

    //流程启动后，任务的负责人就可以查询自己当前需要处理的任务，查询出来的任务都是该用户的待办任务。

    @test

    public void testfindpersonaltasklist() {

        //任务负责人

        string assignee = "liuky" ;

        //根据流程key 和 任务负责人 查询任务

        list<task> list = taskservice.createtaskquery()

                .processdefinitionkey( "myprocess_1" )

                .taskassignee(assignee)

                .list();

        for (task task : list) {

            system.out.println( "流程实例id：" + task.getprocessinstanceid());

            system.out.println( "任务id：" + task.getid());

            system.out.println( "任务负责人：" + task.getassignee());

            system.out.println( "任务名称：" + task.getname());

        }

        //流程实例id：a9b162aa-ffda-11eb-bad1-02004c4f4f50

        //任务id：a9b5815e-ffda-11eb-bad1-02004c4f4f50

        //任务负责人：liuky

        //任务名称：提交申请

    }

@test

    public void complettask(){

        //根据流程key和任务的负责人查询任务并选择其中的一个任务处理,这里用的

        //是singleresult返回一条，真实环境中是通过步骤5中查询出所有的任务，然后在页面上选择一个任务进行处理.

        task task = taskservice.createtaskquery()

                .processdefinitionkey( "myprocess_1" ) //流程key

                .taskassignee( "liuky" )  //要查询的负责人

                .singleresult();

        //完成任务,参数：任务id

        taskservice测试数据plete(task.getid());

    }

//流程结束，或流程流转过程中的历史信息查询

  @test

  public void findhistoryinfo(){

      //获取 actinst表的查询对象

      historicactivityinstancequery instancequery = historyservice.createhistoricactivityinstancequery();

      //查询 actinst表，条件：根据 instanceid 查询

      instancequery.processinstanceid( "fb5b7674-ffde-11eb-91f8-02004c4f4f50" );

      //增加排序操作,orderbyhistoricactivityinstancestarttime 根据开始时间排序 asc 升序

      instancequery.orderbyhistoricactivityinstancestarttime().asc();

      //查询所有内容

      list<historicactivityinstance> activityinstancelist = instancequery.list();

      //输出结果

      for (historicactivityinstance hi : activityinstancelist) {

          system.out.println( "" );

          system.out.println( "===================-===============" );

          system.out.println(hi.getstarttime());

          system.out.println(hi.getassignee());

          system.out.println(hi.getactivityid());

          system.out.println(hi.getactivityname());

          system.out.println(hi.getprocessdefinitionid());

          system.out.println(hi.getprocessinstanceid());

          system.out.println( "===================-===============" );

          system.out.println( "" );

      }

  }

@test

     public void queryprocessdefinition(){

         //得到processdefinitionquery对象

         processdefinitionquery processdefinitionquery = repositoryservice.createprocessdefinitionquery();

         //查询出当前所有的流程定义

         list<processdefinition> definitionlist = processdefinitionquery.processdefinitionkey( "myprocess_1" )

                 .orderbyprocessdefinitionversion()

                 .desc()

                 .list();

         //打印结果

         for (processdefinition processdefinition : definitionlist) {

             system.out.println( "流程定义 id=" +processdefinition.getid());

             system.out.println( "流程定义 name=" +processdefinition.getname());

             system.out.println( "流程定义 key=" +processdefinition.getkey());

             system.out.println( "流程定义 version=" +processdefinition.getversion());

             system.out.println( "流程部署id =" +processdefinition.getdeploymentid());

         }

     }

//删除流程

   @test

   public void deletedeployment(){

       string deploymentid = "125098e1-ffd9-11eb-8847-02004c4f4f50" ;

       //删除流程定义，如果该流程定义已有流程实例启动则删除时出错

       repositoryservice.deletedeployment(deploymentid);

       //设置true 级联删除流程定义，即使该流程有流程实例启动也可以删除，设置为false非级别删除方式，如果流程

       //repositoryservice.deletedeployment(deploymentid, true);

   }