activiti java生成xml activiti claim

Activiti7

记录Activiti7学习笔记，待完善~~~~~

一、Activiti基础篇

1、Activiti介绍

Alfresco软件在2010年5月17日宣布Activiti业务流程管理（BPM）开源项目的正式启动，其首席架构师由业务流程管理BPM的专家 Tom Baeyens担任，Tom Baeyens就是原来jbpm的架构师，而jbpm是一个非常有名的工作流引擎，当然activiti也是一个工作流引擎。
  Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN2.0进行定义，业务流程按照预先定义的流程进行执行，实现了系统的流程由activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

官方地址：https://www.activiti.org/

2、Activiti应用

2.1、Activiti的基本使用

新建普通Maven项目

1、导入依赖

<properties>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <activiti.version>7.0.0.Beta1</activiti.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 模型处理 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 转换 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn json数据转换 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 布局 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- activiti 云支持 -->
        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
    </dependencies>

2、编写activiti.cfg.xml配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">

        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti?characterEncoding=utf8" />
        <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUsername" value="root" />
        <property name="jdbcPassword" value="123456" />
        <property name="databaseSchemaUpdate" value="true" />
    </bean>
</beans>

3、配置日志

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\act\activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n

4、生成表

@org.junit.Test
    public void test1(){
        //生成表
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        System.err.println(defaultProcessEngine);
    }

2.2、表结构介绍

表结构详细介绍：

1、表头介绍

ACT_GE_ （GE） 表示 general 全局通用数据及设置，各种情况都使用的数据。
ACT_HI_ （HI） 表示 history 历史数据表，包含着程执行的历史相关数据，如结束的流程实例，变量，任务，等等
ACT_RE_ （RE） 表示 repository 存储，包含的是静态信息，如，流程定义，流程的资源（图片，规则等）。
ACT_RU_ （RU） 表示 runtime 运行时，运行时的流程变量，用户任务，变量，职责（job）等运行时的数据。Activiti 只存储实例执行期间的运行时数据，当流程实例结束时，将删除这些记录。这就保证了这些运行时的表小且快。

2、全局通用数据 (ACT_GE_*)

3、历史数据表(ACT_HI_*)

4、静态信息表 (ACT_RE_*)

5、运行数据 (ACT_RU_*)

6、其它表

2.3、Service接口介绍

Activiti引擎提供了7大Service接口，均通过processEngine获取，支持链式API风格。

1、RepositoryService

流程仓库服务，管理流程仓库，比如部署、删除、读取流程资源IdentityService身份服务，管理用户、组及其关系

2、RuntimeService

运行服务，处理所有正在运行态的流程实例、任务，启动流程等。

3、TaskService

任务服务，管理（签收、办理、指派等）、查询任务。

4、FormService

表单服务，读取和流程、任务相关的表单数据

5、HistoryService

历史服务，管理所有历史数据

6、ManagementService

引擎管理服务，和具体业务无关，管理引擎。

2.4、流程绘制

使用Eclipse进行绘制

安装插件这里省略，请自行百度

1、创建Activiti文件

2、绘制

3、具体流程

1、点击空白处设置实例id，实例名称

2、分配负责人

点击节点

3、保存生成JPG文件

3、Activiti流程操作

3.1、流程的部署

@org.junit.Test
    public void test2(){
        //部署流程
        //获取ProcessEngine对象
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        //获取RepositoryService进行部署
        RepositoryService repositoryService = defaultProcessEngine.getRepositoryService();
        //使用RepositoryService进行部署
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("bpmn/MyProcess.bpmn")//添加资源
                .addClasspathResource("bpmn/MyProcess.png")//添加资源
                .name("出差申请单")
                .deploy();//部署流程
        //输出流程部署相关的信息
        System.err.println("流程部署的id："+deploy.getId());
        System.err.println("流程部署的名字："+deploy.getName());
    }

3.2、启动流程实例

@org.junit.Test
    public void test3(){
        //启动流程
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        //获取runtimeService进行启动流程
        RuntimeService runtimeService = defaultProcessEngine.getRuntimeService();
        //定义流程id
        String keyid = "myProcess";
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(keyid);
        //输出相关流程实例信息
        System.err.println("流程定义id"+processInstance.getProcessInstanceId());
        System.err.println("流程实例id"+processInstance.getId());
        System.err.println("当前活动的id"+processInstance.getActivityId());
        System.err.println("时间"+processInstance.getStartTime());
    }

3.3、任务查找

@org.junit.Test
    public void test4(){
        //查看自己的任务
        String name ="张三";
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        //获取taskService
        TaskService taskService = defaultProcessEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("myProcess")
                .taskAssignee(name)
                .list();//查询自己所有的任务
        for (Task task : list) {
            System.err.println("流程实例id"+task.getProcessInstanceId());
            System.err.println("流程任务id"+task.getId());
            System.err.println("任务负责人："+task.getAssignee());
            System.err.println("任务名称:"+task.getName());
        }
    }

3.4、流程任务处理

@org.junit.Test
    public void test5(){
        //根据任务id来处理具体某一个任务
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("myProcess")
                .taskAssignee("李四")
                .list();//查询所有的任务
        for (Task task : list) {
            taskService.complete(task.getId());//但是这样是把所有的关于自己的任务都全部执行了
        }
     //实际业务应该是前端把具体某一个任务id传过来，执行具体的某一个任务
    }

3.5、流程的删除

/**
     * 删除流程实例
     */
    @org.junit.Test
    public void test6(){
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = defaultProcessEngine.getRepositoryService();
        //根据流程实例删除
        repositoryService.deleteDeployment("1",true);
    }

3.6、流程实例历史信息查看

/**
     * 查询流程历史信息
     */
    @org.junit.Test
    public void test7(){
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        //查询历史信息通过historyService接口实现
        HistoryService historyService = defaultProcessEngine.getHistoryService();
        //获取Activity表的查询对象
        HistoricActivityInstanceQuery historicActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery();
        //实例id
        historicActivityInstanceQuery.processDefinitionId("myProcess:1:10004");
        historicActivityInstanceQuery.orderByHistoricActivityInstanceStartTime().desc();
        List<HistoricActivityInstance> list = historicActivityInstanceQuery.list();
        //输出查询的结果
        for (HistoricActivityInstance hi : list) {
            System.err.println(hi.getActivityId());
            System.err.println(hi.getActivityName());
            System.err.println(hi.getActivityType());
            System.err.println(hi.getAssignee());
            System.err.println(hi.getProcessDefinitionId());
            System.err.println(hi.getProcessInstanceId());
            System.err.println("--------------------------------------");
        }
    }

3.7、获取当前流程历史信息

HistoricActivityInstanceQuery historicActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery();
		//当前流程
        historicActivityInstanceQuery.processInstanceId("28dde321-1ba4-11ed-9a6c-6ebaef8369a5");
        historicActivityInstanceQuery.orderByHistoricActivityInstanceStartTime().desc();
        List<HistoricActivityInstance> list = historicActivityInstanceQuery.list();
        for (HistoricActivityInstance historicActivityInstance : list) {
            System.err.println(historicActivityInstance.getActivityId());
            System.err.println(historicActivityInstance.getActivityName());
            System.err.println(historicActivityInstance.getActivityType());
            System.err.println(historicActivityInstance.getAssignee());
            System.err.println(historicActivityInstance.getProcessDefinitionId());
            System.err.println(historicActivityInstance.getProcessInstanceId());
            System.err.println("---------------------");
        }

processDefinitionId:流程实例id

processInstanceId：当前流程id

二、Activiti进阶篇

1、个人任务处理

2、排他网关

1、流程绘制

选择网关组件

2、设置条件

前面步骤不变

选中同意节点

![在这里插入图片描述](

选中驳回节点

案例表示：如果同意则流程继续往下走，如果驳回则流程结束。

3、核心代码

//执行自己的任务
    @Test
    public void test4(){
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        //实际业务应该值是由前端传过来，比如1是驳回，4是同意
        Map map = new HashMap();
        map.put("count",4);
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("gateway")
                .taskAssignee("王五")
                .list();
        for (Task task : list) {
            taskService.complete(task.getId(),map);
        }
    }

注意：map中的key一定是我们在网关中设置的条件值

3、激活与挂起

4、组任务

三、Activiti整合SpringBoot篇

1、导入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.0.0.Beta2</version>
        </dependency>
    </dependencies>

2、流程绘制

不同的是设置负责人的方式不同，传统的固定负责人，和用户组显然在实际业务中是不合适的，因为我们并不知道负责人是谁，有几个负责人。

选中经理审批节点，设置负责人

3、添加配置文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/activiti7?characterEncoding=utf8
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

  activiti:
    db-history-used: true  #开启历史表，默认不开启
    history-level: full  #记录历史等级
    database-schema-update: true #所有表进行更新操作，如果表不存在则新建

4、整合SpringSecurity

Activiti7整合SpringBoot集成了SpringSecurity，有强耦合，所有需要配置

1、工具类

package edu.hunnan.net.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.Component;

import java.util.Collection;

@Component
public class SpringSecurity {


    private Logger logger = LoggerFactory.getLogger(SpringSecurity.class);

    @Autowired
    @Qualifier("myUserDetailsService")
    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");
        }
        ("> Logged in as: " + username);
        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);
    }

}

2、配置类

package edu.hunnan.net.config;

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;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Configuration
public class SpringSecurityConfig {
    private Logger logger = LoggerFactory.getLogger(SpringSecurityConfig.class);

    @Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        String[][] usersGroupsAndRoles = {
                {"salaboy", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"bajie", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"wukong", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
        };
		//注意：GROUP_是不变的，后面的可以改变的（activitiTeam），这里一定要和流程绘制中设置的一样，否则没有权限
        for (String[] user : usersGroupsAndRoles) {
            List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));
            ("> 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();
    }
}

5、流程操作

1、生成表和部署流程

@Autowired
    private RuntimeService runtimeService;
    @Autowired
    private ProcessRuntime processRuntime;
    @Autowired
    private SpringSecurity springSecurity;
    @Autowired
    private TaskRuntime taskRuntime;
    @Test
    void contextLoads() {
        //整合SpringBoot之后，生成表和部署流程的操作自动帮我们做了
        System.err.println(runtimeService);
    }

2、启动流程

/**
     * 启动流程
     */
    @Test
    void test2(){
        springSecurity.logInAs("salaboy");
        ProcessInstance processInstance = processRuntime.start(ProcessPayloadBuilder.
                start().
                withProcessDefinitionKey("springboot")
                .build()
        );
        System.err.println("流程实例id"+processInstance.getId());
    }

3、查询任务，拾取任务

/**
     * 查询任务，拾取任务
     */
    @Test
    void test3(){
        springSecurity.logInAs("salaboy");
        //查询任务
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if(tasks!=null&&tasks.getTotalItems()>0){//有任务
            List<Task> content = tasks.getContent();
            for (Task task : content) {
                //拾取任务
                taskRuntime.claim(TaskPayloadBuilder
                        .claim()
                        .withTaskId(task.getId())
                        .build()
                );
                System.err.println("任务"+task);
            }
            Page<Task> tasks1 =taskRuntime.tasks(Pageable.of(0, 10));
            for (Task task : tasks1.getContent()) {
                System.err.println(task);
            }
        }
    }

4、处理任务

/**
     * 处理任务
     */
    @Test
    void test4(){
        springSecurity.logInAs("salaboy");
        //查询任务
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if(tasks!=null&&tasks.getTotalItems()>0){//有任务
            List<Task> content = tasks.getContent();
            for (Task task : content) {
                System.err.println("任务"+task);
                //处理任务
                taskRuntime.complete(TaskPayloadBuilder
                        .complete()
                        .withTaskId(task.getId())
                        .build()
                );
            }
        }
    }

6、整合WebMVC

发现访问接口有强耦合，必须要登录才能访问接口，这个登录页面是SpringSecurity内置的

1、解决方法

1.1.1、在启动类上加上

@SpringBootApplication(exclude = {org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class})

1.1.2、修改配置类

继承WebSecurityConfigurerAdapter

public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {}

1.1.3、再次访问接口

ok,访问成功！