1 Activiti和Spring整合开发

1.1 Activiti和Spring整合的配置

  • 导入相关jar包的Maven坐标：
  1. <properties>
  2.     <activiti.version>7.0.0.GA</activiti.version>
  3. </properties>
  5. <dependencies>
  6.     <dependency>
  7.         <groupId>org.activiti</groupId>
  8.         <artifactId>activiti-engine</artifactId>
  9.         <version>7.0.0.GA</version>
  10.     </dependency>
  11.     <dependency>
  12.         <groupId>org.activiti</groupId>
  13.         <artifactId>activiti-spring</artifactId>
  14.         <version>${activiti.version}</version>
  15.     </dependency>
  16.     <dependency>
  17.         <groupId>org.springframework</groupId>
  18.         <artifactId>spring-test</artifactId>
  19.         <version>5.1.4.RELEASE</version>
  20.     </dependency>
  21.     <dependency>
  22.         <groupId>org.activiti</groupId>
  23.         <artifactId>activiti-bpmn-model</artifactId>
  24.         <version>${activiti.version}</version>
  25.     </dependency>
  26.     <dependency>
  27.         <groupId>org.activiti</groupId>
  28.         <artifactId>activiti-bpmn-converter</artifactId>
  29.         <version>${activiti.version}</version>
  30.     </dependency>
  31.     <dependency>
  32.         <groupId>org.activiti</groupId>
  33.         <artifactId>activiti-json-converter</artifactId>
  34.         <version>${activiti.version}</version>
  35.     </dependency>
  36.     <dependency>
  37.         <groupId>org.activiti</groupId>
  38.         <artifactId>activiti-bpmn-layout</artifactId>
  39.         <version>${activiti.version}</version>
  40.     </dependency>
  41.     <dependency>
  42.         <groupId>org.activiti.cloud</groupId>
  43.         <artifactId>activiti-cloud-services-api</artifactId>
  44.         <version>7-201802-EA</version>
  45.     </dependency>
  46.     <dependency>
  47.         <groupId>mysql</groupId>
  48.         <artifactId>mysql-connector-java</artifactId>
  49.         <version>8.0.19</version>
  50.     </dependency>
  51.     <dependency>
  52.         <groupId>junit</groupId>
  53.         <artifactId>junit</artifactId>
  54.         <version>4.12</version>
  55.     </dependency>
  56.     <!-- log start -->
  57.     <dependency>
  58.         <groupId>org.apache.logging.log4j</groupId>
  59.         <artifactId>log4j-core</artifactId>
  60.         <version>2.13.3</version>
  61.     </dependency>
  62.     <dependency>
  63.         <groupId>org.apache.logging.log4j</groupId>
  64.         <artifactId>log4j-api</artifactId>
  65.         <version>2.13.3</version>
  66.     </dependency>
  67.     <dependency>
  68.         <groupId>org.slf4j</groupId>
  69.         <artifactId>slf4j-api</artifactId>
  70.         <version>1.7.30</version>
  71.     </dependency>
  72.     <dependency>
  73.         <groupId>org.apache.logging.log4j</groupId>
  74.         <artifactId>log4j-slf4j-impl</artifactId>
  75.         <version>2.13.3</version>
  76.     </dependency>
  77.     <!-- log end -->
  78.     <dependency>
  79.         <groupId>org.mybatis</groupId>
  80.         <artifactId>mybatis</artifactId>
  81.         <version>3.4.5</version>
  82.     </dependency>
  83.     <dependency>
  84.         <groupId>commons-dbcp</groupId>
  85.         <artifactId>commons-dbcp</artifactId>
  86.         <version>1.4</version>
  87.     </dependency>
  88. </dependencies>
  90. <dependencyManagement>
  91.     <dependencies>
  92.         <dependency>
  93.             <groupId>org.activiti.cloud.dependencies</groupId>
  94.             <artifactId>activiti-cloud-dependencies</artifactId>
  95.             <version>7.0.0.GA</version>
  96.             <scope>import</scope>
  97.             <type>pom</type>
  98.         </dependency>
  99.     </dependencies>
  100. </dependencyManagement>
  • 创建Spring和Activiti的整合配置文件activiti-spring.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns="http://www.springframework.org/schema/beans"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/context
  8.         http://www.springframework.org/schema/context/spring-context.xsd">
  10.     <!--  配置数据源 -->
  11.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
  12.         <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
  13.         <property name="username" value="root"/>
  14.         <property name="url"
  15.                   value="jdbc:mysql://192.168.1.146:3306/activiti?useUnicode=true&amp;characterEncoding=UTF-8&amp;autoReconnect=true&amp;useSSL=false&amp;serverTimezone=GMT%2B8&amp;allowPublicKeyRetrieval=true"/>
  16.         <property name="password" value="123456"/>
  17.         <property name="maxActive" value="3"/>
  18.         <property name="maxIdle" value="1"/>
  19.     </bean>
  21.     <!-- 配置事务管理器 -->
  22.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  23.         <property name="dataSource" ref="dataSource"/>
  24.     </bean>
  26.     <!-- 工作流引擎配置Bean -->
  27.     <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
  28.         <!-- 数据源 -->
  29.         <property name="dataSource" ref="dataSource"/>
  30.         <!-- 使用Spring的事务管理器 -->
  31.         <property name="transactionManager" ref="transactionManager"/>
  32.         <!-- 数据库的策略 -->
  33.         <property name="databaseSchemaUpdate" value="true"/>
  34.     </bean>
  36.     <!-- 流程引擎 -->
  37.     <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
  38.         <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
  39.     </bean>
  40.     <!-- 资源服务service -->
  41.     <bean id="repositoryService" factory-bean="processEngine"
  42.           factory-method="getRepositoryService"/>
  43.     <!-- 流程运行service -->
  44.     <bean id="runtimeService" factory-bean="processEngine"
  45.           factory-method="getRuntimeService"/>
  46.     <!-- 任务管理service -->
  47.     <bean id="taskService" factory-bean="processEngine"
  48.           factory-method="getTaskService"/>
  49.     <!-- 历史管理service -->
  50.     <bean id="historyService" factory-bean="processEngine"
  51.           factory-method="getHistoryService"/>
  53. </beans>
  • 创建日志文件log4j2.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
  3. <!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
  4. <configuration status="INFO">
  5.     <!--先定义所有的appender-->
  6.     <appenders>
  7.         <!--输出日志信息到控制台-->
  8.         <console name="Console" target="SYSTEM_OUT">
  9.             <!--控制日志输出的格式-->
  10.             <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
  11.         </console>
  12.     </appenders>
  13.     <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
  14.     <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
  15.     <loggers>
  16.         <root level="INFO">
  17.             <appender-ref ref="Console"/>
  18.         </root>
  19.     </loggers>
  20. </configuration>

1.2 测试Activiti和Spring的整合

  • 测试：
  1. package com.sunxiaping.test;
  3. import org.activiti.engine.RepositoryService;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  10. /**
  11.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  12.  * @version 1.0
  13.  * 2020-08-12 09:23
  14.  */
  15. @RunWith(SpringJUnit4ClassRunner.class)
  16. @ContextConfiguration(locations={"classpath:activiti-spring.xml"})
  17. public class Activiti7Test {
  19.     @Autowired
  20.     private RepositoryService repositoryService;
  22.     @Test
  23.     public void test(){
  24.         System.out.println("repositoryService = " + repositoryService);
  25.     }
  26. }

2 Activiti7和SpringBoot的整合开发

2.1 概述

  • Activiti7发布正式版以后，它可以和SpringBoot2.x完全整合。我们可以将Activiti7和SpringBoot整合开发的坐标引入到工程中，从而达到SpringBoot支持Activiti7。
  • SpringBoot整合Activiti7的具体步骤如下：
    • Activiti7新特性和整合开发 - 图1添加SpringBoot整合Activiti7的jar包的坐标。
    • Activiti7新特性和整合开发 - 图2添加SpringSecurity安全框架的整合配置信息。
    • Activiti7新特性和整合开发 - 图3使用Activiti7新支持的接口（ProcessRuntime接口和TaskRuntime接口）来实现工作流开发。
    • Activiti7新特性和整合开发 - 图4使用新的API实现工作流的开发，主要包括：流程定义查询，启动流程实例，任务的查询，任务的完成。

2.2 Activiti和SpringBoot整合的配置

  • 导入相关jar包的坐标：
  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.2.9.RELEASE</version>
  5.     <relativePath/>
  6. </parent>
  8. <dependencies>
  9.     <dependency>
  10.         <groupId>org.springframework.boot</groupId>
  11.         <artifactId>spring-boot-starter-jdbc</artifactId>
  12.     </dependency>
  13.     <dependency>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-web</artifactId>
  16.     </dependency>
  17.     <dependency>
  18.         <groupId>org.springframework.boot</groupId>
  19.         <artifactId>spring-boot-starter-test</artifactId>
  20.         <scope>test</scope>
  21.     </dependency>
  22.     <dependency>
  23.         <groupId>org.activiti</groupId>
  24.         <artifactId>activiti-spring-boot-starter</artifactId>
  25.         <version>7.0.0.GA</version>
  26.     </dependency>
  27.     <dependency>
  28.         <groupId>org.mybatis.spring.boot</groupId>
  29.         <artifactId>mybatis-spring-boot-starter</artifactId>
  30.         <version>2.1.3</version>
  31.     </dependency>
  32.     <dependency>
  33.         <groupId>mysql</groupId>
  34.         <artifactId>mysql-connector-java</artifactId>
  35.     </dependency>
  36. </dependencies>
  38. <build>
  39.     <plugins>
  40.         <plugin>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-maven-plugin</artifactId>
  43.             <version>2.2.9.RELEASE</version>
  44.         </plugin>
  45.     </plugins>
  46. </build>
  • application.yml
  1. spring:
  2.   datasource:
  3.     url: jdbc:mysql://192.168.134.100:3306/activiti?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
  4.     username : root
  5.     password : 123456
  6.     driver-class-name: com.mysql.cj.jdbc.Driver
  7.   activiti:
  8.     database-schema-update: true
  9.     db-history-used: true
  10.     history-level: full
  11.     check-process-definitions: false
  12.     async-executor-activate: true
  • 流程定义文件team01.bpmn

流程定义文件team01.bpmn.jpg

  • SpringSecurity的配置
  1. /*
  2.  * Copyright 2018 Alfresco, Inc. and/or its affiliates.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *       http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  17. package com.sunxiaping.activiti7.config;
  19. import org.slf4j.Logger;
  20. import org.slf4j.LoggerFactory;
  21. import org.springframework.context.annotation.Bean;
  22. import org.springframework.context.annotation.Configuration;
  23. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  24. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  25. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  26. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  27. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  28. import org.springframework.security.core.userdetails.User;
  29. import org.springframework.security.core.userdetails.UserDetailsService;
  30. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  31. import org.springframework.security.crypto.password.PasswordEncoder;
  32. import org.springframework.security.provisioning.InMemoryUserDetailsManager;
  34. import java.util.Arrays;
  35. import java.util.List;
  36. import java.util.stream.Collectors;
  38. /**
  39.  * SpringSecurity的配置类
  40.  */
  41. @Configuration
  42. @EnableWebSecurity
  43. public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
  45.     private Logger logger = LoggerFactory.getLogger(SpringSecurityConfig.class);
  47.     @Override
  48.     public void configure(AuthenticationManagerBuilder auth) throws Exception {
  49.         auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
  50.     }
  52.     @Bean
  53.     public UserDetailsService userDetailsService() {
  55.         InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
  57.         String[][] usersGroupsAndRoles = {
  58.                 {"salaboy", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
  59.                 {"ryandawsonuk", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
  60.                 {"erdemedeiros", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
  61.                 {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
  62.                 {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
  63.         };
  65.         for (String[] user : usersGroupsAndRoles) {
  66.             List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));
  67.             logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]");
  68.             inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]),
  69.                     authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));
  70.         }
  72.         return inMemoryUserDetailsManager;
  73.     }
  76.     @Override
  77.     protected void configure(HttpSecurity http) throws Exception {
  78.         http.csrf().disable()
  79.                 .authorizeRequests()
  80.                 .anyRequest()
  81.                 .authenticated()
  82.                 .and()
  83.                 .httpBasic();
  84.     }
  86.     @Bean
  87.     public PasswordEncoder passwordEncoder() {
  88.         return new BCryptPasswordEncoder();
  89.     }
  90. }
  • UserService.java
  1. package com.sunxiaping.activiti7.service;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.security.core.Authentication;
  6. import org.springframework.security.core.GrantedAuthority;
  7. import org.springframework.security.core.context.SecurityContextHolder;
  8. import org.springframework.security.core.context.SecurityContextImpl;
  9. import org.springframework.security.core.userdetails.UserDetails;
  10. import org.springframework.security.core.userdetails.UserDetailsService;
  11. import org.springframework.stereotype.Component;
  13. import java.util.Collection;
  15. @Component
  16. public class UserService {
  18.     @Qualifier("userDetailsService")
  19.     @Autowired
  20.     private UserDetailsService userDetailsService;
  22.     public void logInAs(String username) {
  24.         UserDetails user = userDetailsService.loadUserByUsername(username);
  25.         if (user == null) {
  26.             throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
  27.         }
  29.         SecurityContextHolder.setContext(new SecurityContextImpl(new Authentication() {
  30.             @Override
  31.             public Collection<? extends GrantedAuthority> getAuthorities() {
  32.                 return user.getAuthorities();
  33.             }
  35.             @Override
  36.             public Object getCredentials() {
  37.                 return user.getPassword();
  38.             }
  40.             @Override
  41.             public Object getDetails() {
  42.                 return user;
  43.             }
  45.             @Override
  46.             public Object getPrincipal() {
  47.                 return user;
  48.             }
  50.             @Override
  51.             public boolean isAuthenticated() {
  52.                 return true;
  53.             }
  55.             @Override
  56.             public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
  58.             }
  60.             @Override
  61.             public String getName() {
  62.                 return user.getUsername();
  63.             }
  64.         }));
  65.         org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
  66.     }
  67. }
  • SpringBoot的启动类：
  1. package com.sunxiaping.activiti7;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class Activiti7SpringBootApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(Activiti7SpringBootApplication.class, args);
  11.     }
  12. }

2.3 测试Activiti和SpringBoot的整合

  • 测试：
  1. package com.sunxiaping.activiti7;
  3. import com.sunxiaping.activiti7.service.UserService;
  4. import org.activiti.api.process.model.ProcessDefinition;
  5. import org.activiti.api.process.model.ProcessInstance;
  6. import org.activiti.api.process.model.builders.ProcessPayloadBuilder;
  7. import org.activiti.api.process.runtime.ProcessRuntime;
  8. import org.activiti.api.runtime.shared.query.Page;
  9. import org.activiti.api.runtime.shared.query.Pageable;
  10. import org.activiti.api.task.model.Task;
  11. import org.activiti.api.task.model.builders.TaskPayloadBuilder;
  12. import org.activiti.api.task.runtime.TaskRuntime;
  13. import org.junit.Test;
  14. import org.junit.runner.RunWith;
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import org.springframework.boot.test.context.SpringBootTest;
  17. import org.springframework.test.context.junit4.SpringRunner;
  19. import java.util.List;
  21. @RunWith(SpringRunner.class)
  22. @SpringBootTest(classes = Activiti7SpringBootApplication.class)
  23. public class Activiti7Test {
  25.     /**
  26.      * 流程定义相关操作
  27.      */
  28.     @Autowired
  29.     private ProcessRuntime processRuntime;
  31.     /**
  32.      * 任务相关操作
  33.      */
  34.     @Autowired
  35.     private TaskRuntime taskRuntime;
  37.     @Autowired
  38.     private UserService userService;
  41.     /**
  42.      * 查看流程定义
  43.      */
  44.     @Test
  45.     public void testQueryProcessDefinition() {
  47.         userService.logInAs("salaboy");
  49.         //分页查询流程定义信息
  50.         Page<ProcessDefinition> page = processRuntime.processDefinitions(Pageable.of(0, 10));
  51.         int totalItems = page.getTotalItems();
  52.         System.out.println("查看部署流程的个数 = " + totalItems);
  54.         List<ProcessDefinition> content = page.getContent();
  55.         for (ProcessDefinition processDefinition : content) {
  56.             String id = processDefinition.getId();
  57.             System.out.println("当前部署的流程定义的id = " + id);
  58.         }
  59.     }
  61.     /**
  62.      * 启动流程实例
  63.      */
  64.     @Test
  65.     public void testStartProcessInstance() {
  66.         userService.logInAs("salaboy");
  67.         ProcessInstance processInstance = processRuntime.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("team01").build());
  68.         System.out.println("流程实例的id = " + processInstance.getId());
  69.     }
  71.     /**
  72.      * 任务分页查询
  73.      */
  74.     @Test
  75.     public void testQueryTask() {
  76.         userService.logInAs("salaboy");
  78.         Page<Task> page = taskRuntime.tasks(Pageable.of(0, 10));
  80.         int totalItems = page.getTotalItems();
  81.         System.out.println("任务的总数 = " + totalItems);
  82.         for (Task task : page.getContent()) {
  83.             String id = task.getId();
  84.             System.out.println("任务的id = " + id);
  85.             String name = task.getName();
  86.             System.out.println("任务名称 = " + name);
  87.         }
  88.     }
  90.     /**
  91.      * 测试查询任务并完成任务
  92.      */
  93.     @Test
  94.     public void testQueryTaskAndCompleteTask(){
  95.         userService.logInAs("salaboy");
  97.         Page<Task> page = taskRuntime.tasks(Pageable.of(0, 10));
  99.         int totalItems = page.getTotalItems();
  100.         System.out.println("任务的总数 = " + totalItems);
  101.         for (Task task : page.getContent()) {
  102.             String id = task.getId();
  103.             System.out.println("任务的id = " + id);
  104.             String name = task.getName();
  105.             System.out.println("任务名称 = " + name);
  107.             //拾取任务
  108.             taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(id).build());
  110.             //完成任务
  111.             taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(id).build());
  113.         }
  114.     }
  115. }