// 获取ProcessEngine对象，这里要求activiti.cfg.xml文件必须在resource下，如果要自定义文件，也可以采用另外的自定义方式
// 这里会自动往数据库里生成25张activiti所需要用的表
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 输出ProcessEngine对象
System.out.println(processEngine);

 @Test
 public void testCreateService() {
   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   // 获取RuntimeService
   RuntimeService runtimeService = processEngine.getRuntimeService();
}

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine(); RepositoryService repositoryService = engine.getRepositoryService();  
// 获取一个 ProcessDefinitionQuery对象 用来查询操作
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery(); List<ProcessDefinition> list = processDefinitionQuery.processDefinitionKey("evection") .orderByProcessDefinitionVersion() // 安装版本排序 .desc() // 倒序 .list(); 
// 输出流程定义的信息 
for (ProcessDefinition processDefinition : list) {
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()); 
}

输出：
流程定义的ID：evection:1:12504 
流程定义的name：
出差申请单 流程定义的key:evection
流程定义的version:1 流程部署的id:12501

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine(); RepositoryService repositoryService = engine.getRepositoryService();
// 删除流程定义，如果该流程定义已经有了流程实例启动则删除时报错
// ACT_RE_DEPLOYMENT的id
repositoryService.deleteDeployment("12501"); 
// 设置为TRUE 级联删除流程定义，及时流程有实例启动，也可以删除，设置为false 非级联删 除操作。
//repositoryService.deleteDeployment("12501",true);

// 1.获取ProcessEngine对象
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RuntimeService对象
RuntimeService runtimeService = processEngine.getRuntimeService();
// 3.根据流程key启动流程（ACT_RE_PROCDEF流程定义表的key）
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("StaffLeave");
// 从实例可以获取一些相关信息
System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
System.out.println("流程实例的ID：" + processInstance.getId());
System.out.println("当前活动的ID：" + processInstance.getActivityId());
 /**
  流程定义的ID：StaffLeave:1:3
  流程实例的ID：2501 (act_hi_procinst表)
  当前活动的ID：null
*/

// 这里写死当前操作的用户
String assignee = "staff";
// 1.获取ProcessEngine对象
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.获取taskService对象
TaskService taskService = processEngine.getTaskService();
// 3.根据流程key和任务负责人来查询待办任务 （流程key指明了当前是什么流程，任务负责人就好比当前登录的用户）
List<Task> taskList = taskService.createTaskQuery()
  .processDefinitionKey("StaffLeave")
  .taskAssignee(assignee)
  .list();
for (Task task : taskList) {
  System.out.println("流程实例id：" + task.getProcessInstanceId());
  System.out.println("任务id:" + task.getId());
  System.out.println("任务负责人：" + task.getAssignee());
  System.out.println("任务名称：" + task.getName());
}

/**
  输出：
  流程实例id：2501
  任务id:2505
  任务负责人：staff
  任务名称：发起请假单
*/

// 这里写死当前操作的用户（通过更换用户即可实现流程的每一步审批）
String assignee = "staff";
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
// 根据流程Key、流程实例id、操作人查询任务
Task task = taskService.createTaskQuery()
  .processDefinitionKey("StaffLeave")
  .taskAssignee(assignee)
  .processInstanceId("2501")
  .singleResult();
if (Objects.isNull(task)) {
  throw new RuntimeException("当前流程不存在或无操作权限");
}
// 完成任务
taskService.complete(task.getId());
// 一个流程实例的每个节点都会生成一个任务，每个任务都会有指定的用户来操作

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
HistoryService historyService = processEngine.getHistoryService();
// 获取 actinst 表的查询对象，可根据流程实例id查询
HistoricActivityInstanceQuery historicActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery();
historicActivityInstanceQuery.processInstanceId("2501");
historicActivityInstanceQuery.orderByHistoricActivityInstanceEndTime().desc();
List<HistoricActivityInstance> list = historicActivityInstanceQuery.list();

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
// 启动流程实例，bs001业务表主键
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("StaffLeave", "bs001");
// 输出该实例的businessKey
System.out.println(processInstance.getBusinessKey());

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
// 查询出要挂起的流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
        .processDefinitionKey("StaffLeave")
        .singleResult();
// 判断实例是否挂起
boolean suspended = processInstance.isSuspended();
if (suspended) {
    // 激活
    System.out.println("当前是挂起状态，正在激活中");
    runtimeService.activateProcessInstanceById(processInstance.getId());
} else {
    // 挂起
    System.out.println("当前是激活状态，正在挂起");
    runtimeService.suspendProcessInstanceById(processInstance.getId());
}

// 1.获取ProcessEngine对象
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RuntimeService对象
RuntimeService runtimeService = processEngine.getRuntimeService();
// 3.根据流程key启动流程（ACT_RE_PROCDEF流程定义表的key），设置Assignee的取值（UEL）
Map<String, Object> map = new HashMap<>(16);
map.put("staff", "Tom");
map.put("grouper", "Jane");
map.put("manager", "Lily");
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("StaffLeaveUEL", map);
// 从实例可以获取一些相关信息
System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
System.out.println("流程实例的ID：" + processInstance.getId());
System.out.println("当前活动的ID：" + processInstance.getActivityId());

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
Map<String, Object> map = new HashMap<>( 16);
map.put("staff", "Tom");

// 在此设置【设置多候选人变量】*，设置完成流程到了这一节点生成任务后，这些人都可以查出该任务
map.put("grouper", "Jane,Kim,Henry");
map.put("manager", "Lily");

ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("ActivitiCandidateDemo", map);
System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
System.out.println("流程实例的ID：" + processInstance.getId());
System.out.println("当前活动的ID：" + processInstance.getActivityId());

String user = "Jane";
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
List<Task> taskList = taskService.createTaskQuery()
        .processDefinitionKey("ActivitiCandidateDemo")
        // 查询这里使用 【taskCandidateUser】
        .taskCandidateUser(user)
        .list();
for (Task task : taskList) {
    System.out.println("流程实例id：" + task.getProcessInstanceId());
    System.out.println("任务id:" + task.getId());
    System.out.println("任务负责人：" + task.getAssignee());
    System.out.println("任务名称：" + task.getName());
}

// 根据任务id和user查询组待办任务
String user = "Jane";
String taskId = "95003";
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery()
        .taskId(taskId)
        .taskCandidateUser(user)
        .singleResult();
if (Objects.isNull(task)) {
    throw new RuntimeException("当前流程不存在或无操作权限");
}
// 拾取任务
taskService.claim(taskId, user);
// 根据用户查询个人任务
Task personTask = taskService.createTaskQuery()
        .taskAssignee(user)
        .singleResult();
System.out.println("流程实例id：" + personTask.getProcessInstanceId());
System.out.println("任务id:" + personTask.getId());
System.out.println("任务负责人：" + personTask.getAssignee());
System.out.println("任务名称：" + personTask.getName());
// 完成任务
taskService.complete(personTask.getId());

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
String user = "Jane";
String taskId = "95003";
Task task = taskService.createTaskQuery()
        .taskId(taskId)
        .taskCandidateUser(user)
        .singleResult();
if (Objects.isNull(task)) {
    throw new RuntimeException("当前流程不存在或无操作权限");
}
// 归还任务
taskService.setAssignee(taskId, null);

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
String user = "Jane";
String taskId = "95003";
Task task = taskService.createTaskQuery()
        .taskId(taskId)
        .taskCandidateUser(user)
        .singleResult();
if (Objects.isNull(task)) {
    throw new RuntimeException("当前流程不存在或无操作权限");
}
// 任务交接,指定新负责人
String newAssignee = "Henry";
taskService.setAssignee(taskId, newAssignee);

package com.huang.activiti.utils;

import org.springframework.beans.factory.annotation.Autowired;
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;

/**
 * SpringSecurity快速工具，Activiti7官方提供的Example，用于Activiti快速鉴权
 *
 * @author huanghwh
 * @date 2022/2/5 下午9:25
 */
@Component
public class SecurityUtil {

    @Autowired
    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);
    }
}

package com.huang.activiti.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
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 java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * SpringSecurity快速配置类，Activiti7官方提供的Example
 * @author huanghwh
 * @date 2022/2/5 下午9:32
 */
@Configuration
@EnableWebSecurity
public class SpringSecurityConfiguration extends WebSecurityConfigurerAdapter {

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

    @Override
    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService());
    }

    @Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        /**
         * 用户角色信息，直接使用内存，暂时不连数据库，权限名字前缀必须带ROLE_
         */
        String[][] usersGroupsAndRoles = {
                {"jack", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"rose", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"tom", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"admin", "password", "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;
    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .anyRequest()
            .authenticated()
            .and()
            .httpBasic();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

@GetMapping("/listAll")
public List<ProcessDefinition> listAll() {
    securityUtil.logInAs("other");
    // processRuntime与Security高度耦合，要求用户必须有ACTIVITI_USER角色
    Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 100));
    List<ProcessDefinition> content = processDefinitionPage.getContent();
    return content;
}

@PostMapping("/startProcess")
public Object startProcess(@RequestBody Map<String, Object> requestMap) {
  securityUtil.logInAs(String.valueOf(requestMap.get("username")));
  // 设置流程参数
  Map<String, Object> paramMap = new HashMap<>(16);
  paramMap.put("staff", String.valueOf(requestMap.get("username")));
  // 【这里设置组别的时候不需要加前缀GROUP_ 否则待办任务查询不到】
  paramMap.put("officeGroup", "activitiTeam");
  paramMap.put("managerGroup", "otherTeam");
  paramMap.put("day", 3);
  ProcessInstance processInstance = processRuntime.start((ProcessPayloadBuilder.start().withProcessDefinitionKey("CandidateGroupDemo1").withVariables(paramMap).build()));
  return processInstance;
}

@GetMapping("/search")
public Object search(String username) {
  securityUtil.logInAs(username);
  // 查询任务(会自动根据当前登录用户筛选)，(API自动查询包含个人任务和组任务)
  Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
  List<Task> taskList = tasks.getContent();
  return taskList;
}

@GetMapping("/pickAndHandle")
public Object pickAndHandle(String username, String taskId) {
  securityUtil.logInAs(username);
  // 查询任务(会自动根据当前登录用户筛选)
  Task task = taskRuntime.task(taskId);
  if (Objects.isNull(task)) {
    throw new RuntimeException("task不存在");
  }
  if (StringUtils.isBlank(task.getAssignee())) {
    // 负责人为空，表面需要拾取
    taskRuntime.claim(TaskPayloadBuilder
                      .claim()
                      .withTaskId(taskId)
                      .build());
  }
  // 完成任务
  taskRuntime.complete(TaskPayloadBuilder
                       .complete()
                       .withTaskId(taskId)
                       .build());
  return task.getId() + " " + task.getName() + " " + "处理完成";
}

@GetMapping("/process")
public Object searchProcess(String username, String instanceId) {
  securityUtil.logInAs(username);
  // 查询实例的所有任务（流程）节点
  HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery();
  List<HistoricTaskInstance> list = historicTaskInstanceQuery.processInstanceId(instanceId).orderByHistoricTaskInstanceStartTime().asc().list();
  return list;
}