Activiti 工作流学习笔记

环境信息:
IntelliJ IDEA 2021.3.3 (Ultimate Edition)
JDK 1.8

Activiti 7

文章目录

Activiti 7
- 一、了解工作流
- - 1.1 什么是工作流
  - 1.2 工作流引擎
  - 1.3 常见的工作流引擎
  - 1.4 Activiti 概述
  - - 1.4.1 Activiti介绍
    - 1.4.2 建模语言BPMN
    - 1.4.3 Activiti使用流程
    - 1.4.4 流程设计工具
    - 1.4.5 下载activiti-explorer
    - 1.4.6 解压获取部署包
    - 1.4.7 部署 activiti-explorer.war
    - 1.4.8 访问activiti-explorer
  - 1.5 Activiti 7
  - - 1.5.1 Activiti7 新特性介绍
- 二、Activiti 流程操作
- - 2.1 流程定义
  - - 2.1.1 新建模型
    - 2.1.2 开始节点
    - 2.1.3 任务节点
    - 2.1.4 结束节点
    - 2.1.5 设置节点属性
    - 2.1.6 设置流程定义key
    - 2.1.7保存流程定义模型
    - 2.1.8 下载流程定义文件
    - 2.1.9 下载流程定义图片
    - 2.1.10 将资源文件放入项目
- 三、实践项目
- - 3.1 创建 Spring Boot 项目：
  - 3.2 配置文件：
  - 3.3 引入依赖
  - 3.4 新写一个Controller
  - 3.5 添加Activiti Maven依赖
  - - 3.5.1 数据库
    - - 1、表的命名规则和作用
      - 2、Activiti 数据表介绍
  - 3.6 Activiti 7 经典类
  - - 3.6.1 流程部署 Deployment
    - 3.6.2 流程定义 ProcessDefinition
    - 3.6.3 流程实例 ProcessInstance
    - 3.6.4 任务处理Task
    - 3.6.5 历史任务 HistoricTaskInstance
    - - A. 历史综合信息 HistoricTaskInstance
      - B. 历史变量：HistoriVariableInstance
  - 3.7 UEL表达式
  - 3.8 BPMN 2.0 网关
  - 3.9 Activiti 新特性
  - 3.10 Spring Security
  - 3.11 BPMN.js
  - - - a. 下载BPMN.js
      - b. 安装Node.js

一、了解工作流

1.1 什么是工作流

工作流（Workflow），就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种**预定义的规则(约定·好的)**自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。通俗来讲，就是业务上一个完整的审批流程。 例如：员工的请假，出差，外出采购，合同审核等等，这些过程，都是一个工作流。

1.2 工作流引擎

对于工作流的处理，如果采用原始的方式，我们需要拿着各种文件到各个负责人那里去签字，需要在多个部门之间不断审批，这种方式费时费力。而我们可以借助软件系统来协助我们处理这些审批流程，这样就出现了工作流系统，使用工作流系统后可以极大的提高工作效率。

工作流模型:
填写请假单 -> 部门经理审批 -> 总经理审批 -> 人事备案

要实现上述的流程，我们自己可以通过字段标识来实现这个审批效果，在业务表中加个字段，比如填写请假单用1标识，部门经理用2标识，总经理用3标识，人事备案用4标识，好像看起来没啥问题，也实现了审批效果。可是一旦我们的流程出现变化，这个时候我们就需要改动我们的代码，这显然是不可取的，需要用专业的方式来实现工作流的管理，并且可以做到业务流程变化之后，我们的程序可以不用改变，流程自动完成。如果可以实现这样的效果，那么我们的业务系统的适应能力就得到了极大提升。在这样的背景下，就出现了工作流引擎。

为什么使用工作流引擎，能实现业务流程改变，不用修改代码，流程还能自动推进？

（1）我们先来说说为什么流程改变，不用修改代码：我们的工作流引擎都实现了一个规范，这个规范要求我们的流程管理与状态字段无关，始终都是读取业务流程图的下一个节点。当业务更新的时候我们只需要更新业务流程图就行了。这就实现了业务流程改变，不用修改代码。

（2）再来说说流程自动推进，这个原理就更简单了，就拿上面的请假模型来说，工作流引擎会用一张数据库表来记录当前处在的节点。当填写完请假单后肯定是要轮到部门经理来审批了，所以我们一旦完成了请假单填写那么这条记录将会被从这张表删除掉，并且会把下一个节点部门经理的信息插入到这张表中，当我们用部门经理的信息去这张表中查询的时候就能查出部门经理相关的审批的信息了，以此类推，这样层层递进，就实现了流程的自动递交了。

1.3 常见的工作流引擎

主流框架有：Activiti、JBPM、Camunda、Flowable，国产的盘古BPM、云程

1.4 Activiti 概述

1.4.1 Activiti介绍

Activiti是一个工作流引擎，可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN进行定义，业务流程按照预先定义的流程进行执行。实现了系统的流程由Activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作流量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

官方网站：https://www.activiti.org

1.4.2 建模语言BPMN

BPM（Business Process Management）即业务流程管理，是一种规范化的构造端到端的业务流程，以持续提高组织业务效率。
BPM 软件就是根据企业中业务环境的变化，推进人与人之间、人与系统之间以及系统与系统之间的整理及调整的经营方法与解决方案的 IT 工具。使用 BPM 软件对企业内部及外部的业务流程的整个生命周期进行建模、自动化、管理监控和优化，可以降低企业成本，提高利润。
BPMN（Business Process Model And Notation）即业务流程模型和符号，是一套标准的业务流程建模符号，使用 BPMN 提供的符号可以创建业务流程。Activit 就是使用 BPMN 进行流程建模、流程执行管理的。
BPMN2.0 是业务流程建模符号 2.0 的缩写，它由 Business Process Management Initiative 这个非营利协会创建并不断发展。BPMN2.0 是使用一些符号来明确业务流程设计流程图的一套符号规范，能增进业务建模时的沟通效率。目前 BPMN2.0 是最新的版本，它用于在 BPM 上下文中进行布局和可视化的沟通。

BPMN2.0 的基本符号主要包含：

事件 Event

开始：表示一个流程的开始

中间：发生的开始和结束事件之间，影响处理的流程

结束：表示该过程结束

活动 Activities

活动是工作或任务的一个通用术语。一个活动可以是一个任务，还可以是一个当前流程的子处理流程；其次，你还可以为活动指定不同的类型。常见活动如下：

网关 GateWay

用于表示流程的分支与合并，有几种常用网关需要了解：
排他网关： 只有一条路径会被选择
并（平）行网关： 所有路径会被同时选择。
包容网关： 可以同时执行多条线路，也可以在网关上设置条件。
事件网关： 专门为中间捕获事件设置的，允许设置多个输出流指向多个不同的中间捕获事件。当流程执行到事件网关后，流程处于等待状态，需要等待抛出事件才能将等待状态转换为活动状态。
流向 Flow

流是连接两个流程节点的连线，常见的流向包含以下几种：
顺序流：用一个带实心箭头的实心线表示，用于指定活动执行的顺序
信息流：用一条带箭头的虚线表示，用于描述两个独立的业务参与者（业务实体/业务角色）之间发送和接受的消息流动
关联：用一根带有线箭头的点线表示，用于将相关的数据、文本和其他人工信息与流对象联系起来。用于展示活动的输入和输出

流程示例：
![

1.4.3 Activiti使用流程

第一步： 引入依赖并初始化数据库

既然activiti是一个框架，那么我们肯定是需要引入对应的jar包坐标的，具体参考代码中的。

第二步： 通过工具绘画流程图

使用 activiti 流程建模工具(activity-designer)定义业务流程(.bpmn 文件)

.bpmn 文件就是业务流程定义文件，通过 xml 定义业务流程。

第三步：流程定义部署;

向 activiti 部署业务流程定义（.bpmn 文件），使用 activiti 提供的 api 向 activiti 中部署.bpmn 文件，

通俗来讲，就是让activiti认识要使用的流程

第四步： 启动一个流程实例（Process Instance）

启动一个流程实例表示开始一次业务流程的运行，比如员工请假流程部署完成，如果张三要请假就可以启动一个流程实例，如果李四要请假也启动一个流程实例，两个流程的执行互相不影响，就好比定义一个java类，实例化两个对象一样，部署的流程就好比java类，启动一个流程实例就好比new一个java对象

第五步： 用户查询待办任务(Task)

因为现在系统的业务流程已经交给 activiti 管理，通过 activiti 就可以查询当前流程执行到哪了，当前用户需要办理什么任务了，这些 activiti帮我们管理了。实际上我们学习activiti也只是学习它的API怎么使用，因为很多功能activiti都已经封装好了，我们会调用就行了

第六步： 用户办理任务

用户查询待办任务后，就可以办理某个任务，如果这个任务办理完成还需要其它用户办理，比如请假单创建后由部门经理审核，这个过程也是由 activiti 帮我们完成了，不需要我们在代码中硬编码指定下一个任务办理人了

第七步： 流程结束

当任务办理完成没有下一个任务节点了，这个流程实例就完成了。

1.4.4 流程设计工具

actiBPM

BPMN-JS

IDEA版本小于等于2019，可使用Activiti插件actiBPM，大于该版本的IDEA可使用Activiti BPMN visualizer插件绘制流程设计。现使用：Activiti Modeler

Activiti Modeler 是 Activiti 官方提供的一款在线流程设计的前端插件，开发人员可以方便在线进行流程设计，保存流程模型，部署至流程定义等等，后续我们的项目也是集成Activiti Modeler绘制流程定义。

1.4.5 下载activiti-explorer

官网下载：https://www.activiti.org/get-started

1.4.6 解压获取部署包

解压activiti-5.22.0.zip，在activiti-5.22.0\wars目录下获取 activiti-explorer.war

1.4.7 部署 activiti-explorer.war

将activiti-explorer.war放到 tomcat部署目录(Tomcat目录下\webapps)，启动 tomcat：双击 apache-tomcat的安装目录\bin\startup.bat

1.4.8 访问activiti-explorer

http://localhost:8080/activiti-explorer

默认登录账号：kermit kermit

上面有很多功能，我们关注流程设计即可，如下图：

点击上图：流程 --> 新建模型 --> 输入模型名称（请假）–> 创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jjgZDKBx-1686055679452)(./doc/photo/15后.PNG)]

1.5 Activiti 7

Activiti项目是基于Apache License许可的开源项目，项目前主管是 Tom Baeyens。Activiti项目前身是JBPM，因此Activiti初始版本是5，Activiti项目支持BPMN标准。

1.5.1 Activiti7 新特性介绍

与Spring Boot更好的原生支持，旧版需要配置activiti.cfg.xml文件，还需要手动加载，新版本只需配置 yml文件即可
引入SpringSecurity作为默认用户与角色的默认安全机制（相比旧版自己配置有点强硬）
核心API进行了封装，封装了不少如none值等判断，让开发者更关注业务流程即可，
对云发布，分布式支持等，去掉了用户和表单两个接口类，需要自己手动添加。
取消了FormService和 IdentityService 模块，将原先RepositorySertvice,RuntimeService,ManagementService,TaskService,HistoryService五个模块合并成ProcessRuntime，TaskRuntime两个模块

二、Activiti 流程操作

2.1 流程定义

我们定义一个请假流程

2.1.1 新建模型

2.1.2 开始节点

2.1.3 任务节点

2.1.4 结束节点

2.1.5 设置节点属性

指定标签名称：张三审批，节点任务负责人：zhangsan

指定标签名称：李四审批，节点任务负责人：lisi

2.1.6 设置流程定义key

2.1.7保存流程定义模型

2.1.8 下载流程定义文件

下载文件为：qingjia.bpmn20.xml


<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
  <process id="qingjia" isExecutable="true">
    <startEvent id="sid-1AB654AE-D3A2-4240-82A7-F8D959B29A9A">startEvent>
    <userTask id="sid-0DAD9B06-6F38-4616-BC16-156989CB12BA" name="张三审批" activiti:assignee="zhangsan">userTask>
    <sequenceFlow id="sid-581CCDA2-D9E0-4C5B-83AE-93F409832ED4" sourceRef="sid-1AB654AE-D3A2-4240-82A7-F8D959B29A9A" targetRef="sid-0DAD9B06-6F38-4616-BC16-156989CB12BA">sequenceFlow>
    <endEvent id="sid-E210AB99-58D8-43D0-B24A-CFF3E85A9512">endEvent>
    <userTask id="sid-E9C4E51D-9F58-4C99-B1A8-E258AD244426" name="李四" activiti:assignee="lisi">userTask>
    <sequenceFlow id="sid-9978CDC0-34F4-40ED-8A7C-80E907514297" sourceRef="sid-0DAD9B06-6F38-4616-BC16-156989CB12BA" targetRef="sid-E9C4E51D-9F58-4C99-B1A8-E258AD244426">sequenceFlow>
    <sequenceFlow id="sid-DE57A74C-09D5-42FE-BE85-A0EAE8CC89EF" sourceRef="sid-E9C4E51D-9F58-4C99-B1A8-E258AD244426" targetRef="sid-E210AB99-58D8-43D0-B24A-CFF3E85A9512">sequenceFlow>
  process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_qingjia">
    <bpmndi:BPMNPlane bpmnElement="qingjia" id="BPMNPlane_qingjia">
      <bpmndi:BPMNShape bpmnElement="sid-1AB654AE-D3A2-4240-82A7-F8D959B29A9A" id="BPMNShape_sid-1AB654AE-D3A2-4240-82A7-F8D959B29A9A">
        <omgdc:Bounds height="30.0" width="30.0" x="136.19997740686003" y="107.99999655783185">omgdc:Bounds>
      bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-0DAD9B06-6F38-4616-BC16-156989CB12BA" id="BPMNShape_sid-0DAD9B06-6F38-4616-BC16-156989CB12BA">
        <omgdc:Bounds height="79.99999999999999" width="100.0" x="224.99999329447763" y="82.99999532103554">omgdc:Bounds>
      bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-E210AB99-58D8-43D0-B24A-CFF3E85A9512" id="BPMNShape_sid-E210AB99-58D8-43D0-B24A-CFF3E85A9512">
        <omgdc:Bounds height="28.00000000000007" width="28.0" x="539.9999919533731" y="108.99999493360532">omgdc:Bounds>
      bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-E9C4E51D-9F58-4C99-B1A8-E258AD244426" id="BPMNShape_sid-E9C4E51D-9F58-4C99-B1A8-E258AD244426">
        <omgdc:Bounds height="80.00000000000001" width="100.0" x="374.9999944120646" y="82.99999369680909">omgdc:Bounds>
      bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="sid-581CCDA2-D9E0-4C5B-83AE-93F409832ED4" id="BPMNEdge_sid-581CCDA2-D9E0-4C5B-83AE-93F409832ED4">
        <omgdi:waypoint x="166.19997740686003" y="122.9999964079777">omgdi:waypoint>
        <omgdi:waypoint x="224.99999329447763" y="122.99999582054932">omgdi:waypoint>
      bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="sid-9978CDC0-34F4-40ED-8A7C-80E907514297" id="BPMNEdge_sid-9978CDC0-34F4-40ED-8A7C-80E907514297">
        <omgdi:waypoint x="324.99999329447763" y="122.99999477962673">omgdi:waypoint>
        <omgdi:waypoint x="374.9999944120646" y="122.99999423821791">omgdi:waypoint>
      bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="sid-DE57A74C-09D5-42FE-BE85-A0EAE8CC89EF" id="BPMNEdge_sid-DE57A74C-09D5-42FE-BE85-A0EAE8CC89EF">
        <omgdi:waypoint x="474.9999944120646" y="122.9999941761875">omgdi:waypoint>
        <omgdi:waypoint x="539.9999919533731" y="122.99999479937941">omgdi:waypoint>
      bpmndi:BPMNEdge>
    bpmndi:BPMNPlane>
  bpmndi:BPMNDiagram>
definitions>

2.1.9 下载流程定义图片

单击右键上图图片，图片另存为：qingjia.PNG

2.1.10 将资源文件放入项目

一般我们将在项目resources下新建BPMN资源文件夹，将qingjia.bpmn20.xml与qingjia.PNG放入BPMN文件夹中：

三、实践项目

3.1 创建 Spring Boot 项目：

配置项目相关信息：

选择Spring相关插件：

Spring Web
JDBC API 连接数据库
MySQL Driver 使用的是MySQL，因此配置MySQL驱动
Mybatis framework 使用Mybatis框架作为持久层的框架

选择JDK版本：1.8

Maven配置（同时Maven最好引用阿里镜像）

3.2 配置文件：

server:
  port: 8080 # 端口号
  servlet:
    context-path: /  # 访问起始路径
spring:
  datasource:  # 数据库连接
    username: root  # 用户名
    password: root  # 密码
    url: jdbc:mysql://127.0.0.1:3306/activiti?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC&nullCatalogMeansCurrent=true 
    driver-class-name: com.mysql.cj.jdbc.Driver  # 驱动

3.3 引入依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.3.2.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.test.activitigroupId>
    <artifactId>activitiartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>activitiname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>

        <dependencies>
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-starter-jdbcartifactId>
            dependency>

            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-starter-webartifactId>
            dependency>

            <dependency>
                <groupId>org.mybatis.spring.bootgroupId>
                <artifactId>mybatis-spring-boot-starterartifactId>
                <version>2.2.2version>
            dependency>

            
            <dependency>
                <groupId>mysqlgroupId>
                <artifactId>mysql-connector-javaartifactId>
                <scope>runtimescope>
            dependency>

            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-starter-testartifactId>
                <scope>testscope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintagegroupId>
                        <artifactId>junit-vintage-engineartifactId>
                    exclusion>
                exclusions>
            dependency>

            
            <dependency>
                <groupId>org.activitigroupId>
                <artifactId>activiti-spring-boot-starterartifactId>
                <version>7.1.0.M4version>
            dependency>

            <dependency>
                <groupId>org.activiti.dependenciesgroupId>
                <artifactId>activiti-dependenciesartifactId>
                <version>7.1.0.M4version>
                <type>pomtype>
            dependency>

            
            <dependency>
                <groupId>org.projectlombokgroupId>
                <artifactId>lombokartifactId>
                <optional>trueoptional>
            dependency>
        dependencies>
project>

3.4 新写一个Controller

创建HelloController.java

package com.test.activiti.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @RequestMapping(value = "hello",method = RequestMethod.GET) //Get 浏览器传参 Post 提交表单方式传参
    public String hello(){
        return "Activiti7 学习";
    }
}

启动后访问：

3.5 添加Activiti Maven依赖

https://activiti.gitbook.io/activiti-7-developers-guide/getting-started/getting-started-activiti-core

当然也可以阿里云查询：

https://developer.aliyun.com/mvn/search



<dependency>
	<groupId>org.activitigroupId>
    <artifactId>activiti-spring-boot-starterartifactId>
    <version>7.1.0.M4version>
dependency>

<dependency>
    <groupId>org.activiti.dependenciesgroupId>
    <artifactId>activiti-dependenciesartifactId>
    <version>7.1.0.M4version>
    <type>pomtype>
dependency>

注意：M5版本以上，会出现每次启动数据库后新生成一条默认数据的BUG，M4版本就不会。

# application.yml
server:
  port: 8080 # 端口号
  servlet:
    context-path: /  # 访问起始路径
spring:
  datasource:  # 数据库连接
    username: root  # 用户名
    password: root  # 密码
    url: jdbc:mysql://127.0.0.1:3306/activiti?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC&nullCatalogMeansCurrent=true
    driver-class-name: com.mysql.cj.jdbc.Driver  # 驱动
# activiti7 历史表创建
spring.activiti.history-level: full # 完整存储
spring.activiti.db-history-used: true # 开启历史表存储
# 自动部署 (关闭)
spring.activiti.check-process-definitions: false

如果是Activiti7以前的版本会需要另写一个activiti.cfg.xml配置文件，启动项目时需要启动。当然activiti 7 也是支持这样的，但是已经能够适配SpringBoot配置文件，这样配置方式是没必要的。

Activiti 7 之前版本：https://www.activiti.org/userguide/

配置完成后，运行即可：生成多个表，User表需要自己创建。

3.5.1 数据库

Activiti 的运行支持必须要有这 25 张表的支持，主要是在业务流程运行过程中，记录参与流程的用户主体，用户组信息，以及流程的定义，流程执行时的信息，和流程的历史信息等等。

1、表的命名规则和作用

观察创建的表，我们发现 Activiti 的表都以 act_ 开头，紧接着是表示表的用途的两个字母标识，也和 Activiti 所提供的服务的 API 对应：

ACT_RE：RE 表示 repository，这个前缀的表包含了部署的流程定义和流程静态资源（图片、规则、等等）
ACT_RU：RU 表示 runtime，这些表运行时，会包含流程实例、任务、变量、异步任务等流程业务进行中的数据。Activiti 只在流程实例执行过程中保存这些数据，在流程结束时就会删除这些记录。这样表就可以一直保持很小的体积，并且速度很快
ACT_HI：HI 表示 history，这些表包含一些历史数据，比如历史流程实例、变量、任务等等
ACT_GE：GE 表示 general，通用数据

2、Activiti 数据表介绍

表分类	表名	解释
一般数据
	[ACT_EVT_LOG]	事件处理日志
	[ACT_GE_BYTEARRAY]	通用的流程定义和流程资源（二进制表）
	[ACT_GE_PROPERTY]	系统相关属性（存BPMN的二进制表）
流程历史记录
	[ACT_HI_ACTINST]	历史节点
	[ACT_HI_ATTACHMENT]	历史的流程附件
	[ACT_HI_COMMENT]	历史的说明性信息
	[ACT_HI_DETAIL]	历史的流程运行中的细节信息
	[ACT_HI_IDENTITYLINK]	历史的流程运行过程中用户关系
	[ACT_HI_PROCINST]	历史的流程实例
	[ACT_HI_TASKINST]	历史的任务实例
	[ACT_HI_VARINST]	历史的流程运行中的变量信息
流程定义表
	[ACT_RE_DEPLOYMENT]	部署单元信息（部署表）
	[ACT_RE_MODEL]	模型信息
	[ACT_RE_PROCDEF]	已部署的流程定义
运行实例表
	[ACT_RU_EVENT_SUBSCR]	运行时事件
	[ACT_RU_EXECUTION]	运行时流程执行实例
	[ACT_RU_IDENTITYLINK]	运行时用户关系信息，存储任务节点与参与者的相关信息
	[ACT_RU_JOB]	运行时作业
	[ACT_RU_TASK]	运行时任务
	[ACT_RU_VARIABLE]	运行时变量表

3.6 Activiti 7 经典类

3.6.1 流程部署 Deployment

Deployment：添加资源文件、获取部署信息、部署时间

指定流程key
制定流程名称
任务指定执行人
上传bpmn、上传bpmn和图片、上传zip
增删改查
查询列表和查询xml

package com.test.activiti;

import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.InputStream;
import java.util.List;

@SpringBootTest
public class Part1_Deployment {

    @Autowired
    private RepositoryService repositoryService;

    /**
     * 通过bpmn部署流程
     */
    @Test
    public void initDeploymentBPMN() {
        String filename = "BPMN/diagram.bpmn"; //resources 目录下
        //String pngname = "BPMN/bpmn.PNG";
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource(filename)
                //.addClasspathResource(pngname)//图片 原来需要上传bpmnxml文件的同时上传一张相应行的图片用来展现
                .name("流程部署测试BPMN") //如果数据库遇到多个相同文件，会在之后追加_V2
                .deploy();
        System.out.println(deployment.getName());
    }
}

注意：deployment 选择org.activiti.engine.repository 包：

运行成功

/**
 * 通过bpmn部署流程
 */
@Test
public void initDeploymentBPMN() {
    String pngname = "BPMN/bpmn.PNG";//resources 目录下
    Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource(pngname)//图片 原来需要上传bpmnxml文件的同时上传一张相应行的图片用来展现
            .name("流程部署测试BPMN") //如果数据库遇到多个相同文件，会在之后追加_V2
            .deploy();
    System.out.println(deployment.getName());
}

   /**
     * 通过zip部署流程
     */
    @Test
    public void initDemploymentZIP(){
        InputStream fileInputStream = this.getClass()
                .getClassLoader()
                .getResourceAsStream("BPMN/bpmn.zip");
        ZipInputStream zip = new ZipInputStream(fileInputStream);
        Deployment deployment = repositoryService.createDeployment()
                .addZipInputStream(zip)
                .name("流程部署测试zip")//zip中存在xml和jpg文件，存入数据库会自动解压生成两条数据
                .deploy();
        System.out.println(deployment.getName());
    }

之前：

之后：

可以看到zip文件上传，压缩文件被解压缩了。

   /**
     * 查询流程部署
     */
    @Test
    public void getDeployments(){
        List<Deployment>  list =repositoryService.createDeploymentQuery().list();
        for (Deployment deployment :list){
            System.out.println("Id:"+deployment.getId());
            System.out.println("Name:"+deployment.getName());
            System.out.println("Time:"+deployment.getDeploymentTime());
            System.out.println("Key:"+deployment.getKey());
        }
    }

全部代码：

package com.test.activiti;

import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.InputStream;
import java.util.List;
import java.util.zip.ZipInputStream;

@SpringBootTest
public class Part1_Deployment {

    @Autowired
    private RepositoryService repositoryService;
    
     /**
     * 通过bpmn部署流程
     */
    @Test
    public void initDeploymentBPMN() {
        String filename = "BPMN/diagram.bpmn"; //resources 目录下
        //String pngname = "BPMN/bpmn.PNG";
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource(filename)
                //.addClasspathResource(pngname)//图片 原来需要上传bpmnxml文件的同时上传一张相应行的图片用来展现
                .name("流程部署测试BPMN") //如果数据库遇到多个相同文件，会在之后追加_V2
                .deploy();
        System.out.println(deployment.getName());
    }
    
    /**
     * 通过zip部署流程
     */
    @Test
    public void initDemploymentZIP(){
        InputStream fileInputStream = this.getClass()
                .getClassLoader()
                .getResourceAsStream("BPMN/bpmn.zip");
        ZipInputStream zip = new ZipInputStream(fileInputStream);
        Deployment deployment = repositoryService.createDeployment()
                .addZipInputStream(zip)
                .name("流程部署测试zip")//zip中存在xml和jpg文件，存入数据库会自动解压生成两条数据
                .deploy();
        System.out.println(deployment.getName());
    }

    /**
     * 查询流程部署
     */
    @Test
    public void getDeployments(){
        List  list =repositoryService.createDeploymentQuery().list();
        for (Deployment deployment :list){
            System.out.println("Id:"+deployment.getId());
            System.out.println("Name:"+deployment.getName());
            System.out.println("Time:"+deployment.getDeploymentTime());
            System.out.println("Key:"+deployment.getKey());
        }
    }
}

3.6.2 流程定义 ProcessDefinition

流程部署
Deployment：添加资源文件、获取部署信息、部署时间

流程定义
ProcessDefinition：获取版本号、key、资源名称、部署ID等
key不变就是同一个流程，多加v2 v3的版本

package com.test.activiti;

import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.ProcessDefinition;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;

@SpringBootTest
public class Part2_ProcessDefinition {

    @Autowired
    private RepositoryService repositoryService;

    /**
     * 查询流程定义
     */
    @Test
    public void getDefinitions(){
        // ProcessDefinition 是 org.activiti.engine.repository.ProcessDefinition 这个类
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()
                .list();
        for (ProcessDefinition pd: list){
            System.out.println("---------流程定义-----------");
            System.out.println("Name:"+pd.getName());
            System.out.println("Key:"+pd.getKey());
            System.out.println("ResourceName:"+pd.getResourceName());
            System.out.println("DeploymentId:"+pd.getDeploymentId());
            System.out.println("Version:"+pd.getVersion());
            System.out.println("===========================");
        }
    }

    @Test
    public  void delDefinition(){
        String pdID = "af658828-c940-11ed-9559-005056c00008";
        repositoryService.deleteDeployment(pdID,true); //true 删除下列 所有的历史， false会保留历史任务，一般真实情况下都是false要留痕迹
        System.out.println("删除流程定义成功！");
    }
}

查询结果：

要删除的：

删除成功

删除后结果

3.6.3 流程实例 ProcessInstance

流程定义 ProcessDefinition 与流程实例 ProcessInstance 是一对多关系，一个流程定义能变成多个流程实例
理解为：行动计划与具体行动的关系。
流程定义 ProcessDefinition 相当于活动方案
流程实例 ProcessInstance 每一次执行这个方案的实际行动

package com.test.activiti;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class Part3_ProcessInstance {

    @Autowired
    private RuntimeService runtimeService;

    //初始化流程实例列表
    @Test
    public void initProcessInstance(){
        //1、获取页面表单填报的内容，请假时间，请假事由，String fromData
        //2、fromData 写入业务表，返回业务表主键ID==businessKey
        //3、把业务数据与Acitivi7流程数据关联
        //4、可以执行多次该方法
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_claim","claim");
        System.out.println("流程实例ID:"+processInstance.getProcessInstanceId());
    }
}

注意：ProcessInstance 使用 org.activiti.engine.runtime.ProcessInstance 包

运行时流程执行实例

数据库增加

act_ru_execution 两条，因为是两个节点，（不包括结束节点）
act_ru_identitylink 运行市里人员

    //获取流程实例列表
    @Test
    public void getProcessInstance(){
        List<ProcessInstance> list = runtimeService.createProcessInstanceQuery().list();
        for (ProcessInstance pi: list) {
            System.out.println("--------流程实例--------");
            System.out.println("ProcessInstanceId:"+pi.getProcessInstanceId());//流程实例id uuid
            System.out.println("ProcessDefinitionId:"+pi.getProcessDefinitionId()); //流程定义id：processDefinitionKey + 版本号 + uuid
            System.out.println("执行结束isEnded:"+pi.isEnded());
            System.out.println("是否挂起流程实例isSuspended:"+pi.isSuspended());
        }
    }

	//暂停流程实例
    @Test
    public void stopProcessInstances(){
        runtimeService.suspendProcessInstanceById("8f229d56-ca09-11ed-8386-005056c00008");//流程实例id
        System.out.println("挂起流程实例");
    }

  //激活流程实例
    @Test
    public void activitieProcessInstances(){
        runtimeService.activateProcessInstanceById("8f229d56-ca09-11ed-8386-005056c00008");//流程实例id
        System.out.println("激活流程实例");
    }

	//删除流程实例
    @Test
    public void delProcessInstances(){
        runtimeService.deleteProcessInstance("8f229d56-ca09-11ed-8386-005056c00008","删除原因：删除测试");//流程实例id 删除原因deleteReason
        System.out.println("删除流程实例");
    }

package com.test.activiti;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part3_ProcessInstance {

    @Autowired
    private RuntimeService runtimeService;

    //初始化流程实例列表
    @Test
    public void initProcessInstance(){
        //1、获取页面表单填报的内容，请假时间，请假事由，String fromData
        //2、fromData 写入业务表，返回业务表主键ID==businessKey
        //3、把业务数据与Acitivi7流程数据关联
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_claim","claim");
        System.out.println("流程实例ID:"+processInstance.getProcessInstanceId());
    }

    //获取流程实例列表
    @Test
    public void getProcessInstance(){
        List<ProcessInstance> list = runtimeService.createProcessInstanceQuery().list();
        for (ProcessInstance pi: list) {
            System.out.println("--------流程实例--------");
            System.out.println("ProcessInstanceId:"+pi.getProcessInstanceId());//流程实例id uuid
            System.out.println("ProcessDefinitionId:"+pi.getProcessDefinitionId()); //流程定义id：processDefinitionKey + 版本号 + uuid
            System.out.println("执行结束isEnded:"+pi.isEnded());
            System.out.println("是否挂起流程实例isSuspended:"+pi.isSuspended());
        }
    }

    //暂停流程实例
    @Test
    public void stopProcessInstances(){
        runtimeService.suspendProcessInstanceById("8f229d56-ca09-11ed-8386-005056c00008");//流程实例id
        System.out.println("挂起流程实例");
    }

    //激活流程实例
    @Test
    public void activitieProcessInstances(){
        runtimeService.activateProcessInstanceById("8f229d56-ca09-11ed-8386-005056c00008");//流程实例id
        System.out.println("激活流程实例");
    }

    //删除流程实例
    @Test
    public void delProcessInstances(){
        runtimeService.deleteProcessInstance("8f229d56-ca09-11ed-8386-005056c00008","删除原因：删除测试");//流程实例id 删除原因deleteReason
        System.out.println("删除流程实例");
    }
}

3.6.4 任务处理Task

用户任务属性面板
Assignee: 执行人、代理人
Candidate Users: 候选人（多个用户）
Candidate Groups: 候选组
Due Date: 任务到期时间

新设计工作流：

涉及的表:

运行时
ACT_RU_TASK运行时任务节点

先部署事件：

package com.test.activiti;

import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part4_Task {

    @Autowired
    private TaskService taskService;

    //任务查询
    @Test
    public void getTasks(){
        List<Task> list  = taskService.createTaskQuery().list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }
}

    //查询我的待办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery()
                .taskAssignee("bajie") //或者填wukong
                .list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

    //执行任务
    @Test
    public void completeTask(){ //848df66b-ca1a-11ed-b383-005056c00008 候选人任务
        taskService.complete("848df66b-ca1a-11ed-b383-005056c00008");//d74d1e61-ca16-11ed-9636-005056c00008
        System.out.println("完成任务");
    }

	//拾取任务
    @Test
    public void claimTask(){
//        //查询候选人
//        List list = taskService.createTaskQuery()
//                .taskCandidateUser("bajie") //Activiti6 之前可以 Activiti7不行
//                .list();
        Task task = taskService.createTaskQuery()
                .taskId("848df66b-ca1a-11ed-b383-005056c00008")
                .singleResult();
        taskService.claim("848df66b-ca1a-11ed-b383-005056c00008","bajie");//任务id taskId 用户id userId
    }

    //归还任务
    @Test
    public void setTaskAssignee(){
        Task task = taskService.createTaskQuery()
                .taskId("848df66b-ca1a-11ed-b383-005056c00008")
                .singleResult();
        //taskService.setAssignee("848df66b-ca1a-11ed-b383-005056c00008","null"); //归还后候选任务
        taskService.setAssignee("848df66b-ca1a-11ed-b383-005056c00008","wukong");//交办 交给已知执行人
    }

全部代码：

package com.test.activiti;

import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part4_Task {

    @Autowired
    private TaskService taskService;

    //任务查询
    @Test
    public void getTasks(){
        List<Task> list  = taskService.createTaskQuery().list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

    //查询我的待办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery()
                .taskAssignee("wukong")
                .list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

    //执行任务
    @Test
    public void completeTask(){ //848df66b-ca1a-11ed-b383-005056c00008 候选人任务
        taskService.complete("848df66b-ca1a-11ed-b383-005056c00008");//d74d1e61-ca16-11ed-9636-005056c00008
        System.out.println("完成任务");
    }

    //拾取任务
    @Test
    public void claimTask(){
//        //查询候选人
//        List list = taskService.createTaskQuery()
//                .taskCandidateUser("bajie") //Activiti6 之前可以 Activiti7不行
//                .list();
        Task task = taskService.createTaskQuery()
                .taskId("848df66b-ca1a-11ed-b383-005056c00008")
                .singleResult();
        taskService.claim("848df66b-ca1a-11ed-b383-005056c00008","bajie");
    }

    //归还任务
    @Test
    public void setTaskAssignee(){
        Task task = taskService.createTaskQuery()
                .taskId("848df66b-ca1a-11ed-b383-005056c00008")
                .singleResult();
        //taskService.setAssignee("848df66b-ca1a-11ed-b383-005056c00008","null"); //归还后候选任务
        taskService.setAssignee("848df66b-ca1a-11ed-b383-005056c00008","wukong");//交办 交给已知执行人
    }
}

3.6.5 历史任务 HistoricTaskInstance

历史综合信息：HistoricTaskInstance
历史变量：HistoriVariableInstance

A. 历史综合信息 HistoricTaskInstance

package com.test.activiti;

import org.activiti.engine.HistoryService;
import org.activiti.engine.history.HistoricTaskInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part5_HistoricTaskInstance {

    @Autowired
    private HistoryService historyService;

    //根据用户名查询历史记录
    @Test
    public void HistoricTaskInstanceByUser(){
        List<HistoricTaskInstance> list = historyService
                .createHistoricTaskInstanceQuery()
                .orderByHistoricTaskInstanceEndTime()
                .asc()//正序 desc 倒叙
                .taskAssignee("bajie")
                .list();
        for (HistoricTaskInstance hi : list){
            System.out.println("Id:"+hi.getId());
            System.out.println("ProcessInstanceId:"+hi.getProcessInstanceId());
            System.out.println("Name:"+hi.getName());
        }
    }
}

B. 历史变量：HistoriVariableInstance

    //根据流程实例ID查询历史
    @Test
    public void HistoricTaskInstanceByProcessInstance(){
        List<HistoricTaskInstance> list = historyService
                .createHistoricTaskInstanceQuery()
                .orderByHistoricTaskInstanceEndTime()
                .asc()//正序 desc 倒叙
                .processInstanceId("84891467-ca1a-11ed-b383-005056c00008") //审核人任务 这里所有的id在真实场景下都应该是变量
                .list();
        for (HistoricTaskInstance hi : list){
            System.out.println("Id:"+hi.getId());
            System.out.println("ProcessInstanceId:"+hi.getProcessInstanceId());
            System.out.println("Name:"+hi.getName());
        }
    }

历史节点

历史流程实例

历史人物实例

历史流程人员：每一个人物环节操作，执行人谁？

3.7 UEL表达式

EL表达式语言(Expression Language)
UEL统一表达式语言(Unified Expression Languange) 使用activiti时，动态赋值用的

表达式以 ${ 开始，以 } 结束，例如 ${day > 100}
支持逻辑运算 ${userName == "bajie" and pwd == "123 }
支持变量与实体类赋值
**使用场景：**对执行流程变量赋值，但不要反复赋值（可能存在BUG）。
流程实例启动环节可以赋值，任务完成环节。

对应activiti数据表
act_ru_variable 运行时参数表
act_hi_varinst 历史参数表 varinst参数实例缩写

	UEL表达式的保留字
and	eq	gt
instanceof	div	or
le	false	empty
not	Lt	ge

UEL表达式的运算符
运算符	功能	示例	结果
+	加	`${1 + 1 }`	2
-	div	`${1 - 1 }`	0
*	乘	`${2 * 2 }`	4
/或div	除	2/1或{2 div 1}	2
/或div	除	2/0或{2 div 0}	Infinity
% 或 mod	求余	{3%2}或{3mod2}	1
% 或 mod	求余	{3%0}或{3mod0}	异常 java.lang.ArithmenticException:/by zero

package com.test.activiti;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.Map;

@SpringBootTest
public class Part6_UEL {

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    //任务 流程实例启动环节 任务完成 任意时刻
    //启动流程实例带参数，执行执行人
    @Test
    public void initProcessInstanceWithArgs() {
        //1、获取页面表单填报的内容，请假时间，请假事由，String fromData
        //2、fromData 写入业务表，返回业务表主键ID==businessKey
        //3、把业务数据与Acitivi7流程数据关联
        //4、流程变量
        Map<String,Object> variables = new HashMap<String,Object>();
        variables.put("ZhiXingRen","wukong");
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey("myProcess_claim","claim",variables);
        System.out.println("流程实例ID:"+processInstance.getProcessInstanceId());
    }

    //完成任务带参数
    @Test
    public void completeTaskWItchArgs(){
        Map<String,Object> variables = new HashMap<String,Object>();
        variables.put("pay","101");
        taskService.complete("",null);
        System.out.println("完成任务");
    }

    //启动流程实例带参数，使用实体类  //npmn 必须是小写
    @Test
    public void initProcessInstanceWitchClassArgs(){
        UEL_POJO uel_pojo = new UEL_POJO();
        uel_pojo.setZhixingren("bajie");

        Map<String,Object> variables = new HashMap<String,Object>();
        variables.put("uelpojo",uel_pojo);
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_claim",
                        "bKey002",
                        variables);
        System.out.println("流程实例ID:"+processInstance.getProcessInstanceId());
    }

    //任务完成环节带参数，指定多个候选人
    @Test
    public void initProcessInstanceWithCandiDateArgs(){
        Map<String,Object> variables = new HashMap<String,Object>();
        variables.put("houxuanren","wukong，tangseng");
        taskService.complete("",null);
        System.out.println("完成任务");
    }

    //直接指定流程变量
    @Test
    public void otherArgs(){
        runtimeService.setVariable("","pay","101");
//        runtimeService.setVariables();
//        runtimeService.setVariable();
//        runtimeService.setVariables();
    }

    //局部变量
    @Test
    public void otherLocalArgs(){
        runtimeService.setVariableLocal("","pay","101");
        //        runtimeService.setVariables();
//        runtimeService.setVariable();
//        runtimeService.setVariables();
    }
}

流程部署：

/**
     * 通过bpmn部署流程
     */
    @Test
    public void initDeploymentBPMN2() {
        String filename = "BPMN/Part6_UEL_V2.bpmn"; //resources 目录下Part6_UEL_V2.bpmn 文件
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource(filename)
                .name("流程Part6_UEL_V2.bpmn部署") //如果数据库遇到多个相同文件，会在之后追加_V2
                .deploy();
        System.out.println(deployment.getName());
    }

初始化实例：

//初始化流程实例列表
    @Test
    public void initProcessInstance(){
        //1、获取页面表单填报的内容，请假时间，请假事由，String fromData
        //2、fromData 写入业务表，返回业务表主键ID==businessKey
        //3、把业务数据与Acitivi7流程数据关联
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey("myProcess_1uel_V2","claim"); // 流程实例的key processDefinitionKey, 业务表单关联 businessKey (暂时没用)
        System.out.println("流程实例ID:"+processInstance.getProcessInstanceId());
    }

bajie存在任务：

 //查询我的待办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery()
                .taskAssignee("bajie")
                .list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

没有tangseng的任务：

 //查询我的待办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery()
                .taskAssignee("tangseng")
                .list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

完成任务，并将pay赋值 101：

    //完成任务带参数
    @Test
    public void completeTaskWItchArgs(){
        Map<String,Object> variables = new HashMap<String,Object>();
        variables.put("pay","101");
        taskService.complete("e8e412fa-ebe6-11ed-be61-005056c00008",variables);
        System.out.println("完成任务");
    }

此时唐僧存在任务了：

//查询我的待办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery()
                .taskAssignee("tangseng")
                .list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

声明实体类：

package com.test.activiti;

import lombok.Data;
import java.io.Serializable;

@Data //lombok
public class UEL_POJO implements Serializable {
    private String zhixingren;
    private String pay;

}

    //直接指定流程变量 全局变量
    @Test
    public void otherArgs(){
        runtimeService.setVariable("","pay","101");//流程实例id，参数，参数值
//        runtimeService.setVariables();//可设置多个参数
//        taskService.setVariable();
//        runtimeService.setVariables();// 可赋值多个
    }

    //局部变量 当前环节设置有用
    @Test
    public void otherLocalArgs(){
        runtimeService.setVariableLocal("","pay","101");//流程实例id，参数，参数值
        //        runtimeService.setVariables();
//        runtimeService.setVariable();
//        runtimeService.setVariables();
    }

3.8 BPMN 2.0 网关

事件，事件大于等于两个

并行网关

 /**
     * 通过bpmn部署流程
     */
    @Test
    public void initDeploymentBPMN2() {
        String filename = "BPMN/Part7_1_Parallel.bpmn"; //resources 目录下
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource(filename)
                .name("流程Part7_1_Parallel.bpmn部署") //如果数据库遇到多个相同文件，会在之后追加_V2
                .deploy();
        System.out.println(deployment.getName());
    }

 //启动流程实例
    @Test
    public void initProcessInstanceWitchArgs(){
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_Parallel");
        System.out.println("流程示例ID"+processInstance.getProcessDefinitionId());
    }6b7330e6-ed49-11ed-a19e-005056c00008
        39887e29-ed4b-11ed-8e48-005056c00008

 /**
     * 通过bpmn部署流程
     */
    @Test
    public void initDeploymentBPMN2() {
        String filename = "BPMN/Part7_2_Exclusive.bpmn"; //resources 目录下
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource(filename)
                .name("流程Part7_2_Exclusive.bpmn部署") //如果数据库遇到多个相同文件，会在之后追加_V2
                .deploy();
        System.out.println(deployment.getName());
    }

//启动流程实例
    @Test
    public void initProcessInstanceWitchArgs(){
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_Exclusive");
        System.out.println("流程示例ID"+processInstance.getProcessDefinitionId());
    }8e0074f2-ed4e-11ed-b766-005056c00008

包含网关：多个结果

/**
     * 通过bpmn部署流程
     */
    @Test
    public void initDeploymentBPMN2() {
        String filename = "BPMN/Part7_4_Inclusive.bpmn"; //resources 目录下
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource(filename)
                .name("流程Part7_4_Inclusive.bpmn部署") //如果数据库遇到多个相同文件，会在之后追加_V2
                .deploy();
        System.out.println(deployment.getName());
    }

    //启动流程实例
    @Test
    public void initProcessInstanceWitchArgs(){
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_Inclusive");
        System.out.println("流程示例ID"+processInstance.getProcessDefinitionId());
    }633cd72a-ed63-11ed-8848-005056c00008
        97a4f9d6-ed63-11ed-8d87-005056c00008
        97a8f17a-ed63-11ed-8d87-005056c00008

//查询我的待办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery()
                .taskAssignee("bajie")
                .list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

	//完成任务带参数
    @Test
    public void completeTaskWItchArgs(){
        Map<String,Object> variables = new HashMap<String,Object>();
        variables.put("day","1");
        taskService.complete("97a8f17a-ed63-11ed-8d87-005056c00008",variables);
        System.out.println("完成任务");
    }

   //任务查询
    @Test
    public void getTasks(){
        List<Task> list  = taskService.createTaskQuery().list();
        for (Task tk : list){
            System.out.println("Id:"+tk.getId());
            System.out.println("Name:"+tk.getName());
            System.out.println("执行人Assignee:"+tk.getAssignee());
        }
    }

 @Test
    public void completeTask2(){
        //沙僧包含任务:a7958645-ed64-11ed-9b87-005056c00008
        //悟空包含任务:a7958647-ed64-11ed-9b87-005056c00008
        taskService.complete("a7958645-ed64-11ed-9b87-005056c00008");
        taskService.complete("a7958647-ed64-11ed-9b87-005056c00008");
        System.out.println("完成任务");
    }

3.9 Activiti 新特性

/*
 * Copyright 2010-2020 Alfresco Software, Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.test.activiti;

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

@Component
public class SecurityUtil {
        //登陆类 借助spring security
    private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);

    @Autowired
    private UserDetailsService userDetailsService;

    public void logInAs(String username) { //用username去登录

        UserDetails user = userDetailsService.loadUserByUsername(username);
        if (user == null) {
            throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
        }
        logger.info("> 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);
    }
}

用户创建：（仅用于测试）

/*
 * Copyright 2010-2020 Alfresco Software, Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.test.activiti;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
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;

import static java.util.Arrays.asList;

//@Configuration
public class DemoApplicationConfiguration {

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

    //@Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        String[][] usersGroupsAndRoles = {
                {"bob", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"bajie", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},//john
                {"wukong", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},//hannah
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"system", "password", "ROLE_ACTIVITI_USER"},
                {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
        };

        for (String[] user : usersGroupsAndRoles) {
            List<String> authoritiesStrings = 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 com.test.activiti;

import org.activiti.api.model.shared.model.VariableInstance;
import org.activiti.api.process.model.ProcessInstance;
import org.activiti.api.process.model.builders.ProcessPayloadBuilder;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.core.authority.AuthorityUtils;

import java.util.List;

@SpringBootTest
public class Part8_ProcessRuntime {

    @Autowired
    private ProcessRuntime processRuntime;

    @Autowired
    private SecurityUtil securityUtil;
   
}

//获取流程实例
    @Test
    public void getProcessInstance() {
        securityUtil.logInAs("bajie");
        Page<ProcessInstance> processInstancePage = processRuntime
                .processInstances(Pageable.of(0, 100));//分页查询

        System.out.println("流程实例数量：" + processInstancePage.getTotalItems());

        List<ProcessInstance> list = processInstancePage.getContent();

        for (ProcessInstance pi : list) {
            System.out.println("Id:" + pi.getId());
            System.out.println("Name:" + pi.getName());
            System.out.println("StartDate:" + pi.getStartDate());
            System.out.println("Status:" + pi.getStatus());
            System.out.println("ProcessDefinitionId:" + pi.getProcessDefinitionId()); //流程定义Id
            System.out.println("ProcessDefinitionKey:" + pi.getProcessDefinitionKey());//流程定义key
            
        }
    }

7 engine下，5和6都是api下

//启动流程实例
    @Test
    public void startProcessInstance() {
        securityUtil.logInAs("bajie");
        ProcessInstance processInstance = processRuntime.start(ProcessPayloadBuilder
                .start().withProcessDefinitionKey("myProcess_ProcessRuntime")
                .withName("第一个流程实例名称")
                //.withVariable("","")
                .withBusinessKey("自定义Key")
                .build()
        );
    }

//获取流程实例
    @Test
    public void getProcessInstance() {
        securityUtil.logInAs("bajie");
        Page<ProcessInstance> processInstancePage = processRuntime
                .processInstances(Pageable.of(0, 100));//分页查询

        System.out.println("流程实例数量：" + processInstancePage.getTotalItems());

        List<ProcessInstance> list = processInstancePage.getContent();

        for (ProcessInstance pi : list) {
            System.out.println("Id:" + pi.getId());
            System.out.println("Name:" + pi.getName());
            System.out.println("StartDate:" + pi.getStartDate());
            System.out.println("Status:" + pi.getStatus());
            System.out.println("ProcessDefinitionId:" + pi.getProcessDefinitionId()); //流程定义Id
            System.out.println("ProcessDefinitionKey:" + pi.getProcessDefinitionKey());//流程定义key

        }
    }

//删除流程实例
    @Test
    public void delProcessINstance() {
        securityUtil.logInAs("bajie");
        ProcessInstance processInstance = processRuntime.delete(ProcessPayloadBuilder
                .delete()
                .withProcessInstanceId("31a677d2-ed6b-11ed-b88c-005056c00008")
                .build());
    }

 //挂起流程示例
    @Test
    public void suspendProcessInstance() {
        securityUtil.logInAs("bajie");
        ProcessInstance processInstance = processRuntime.suspend(ProcessPayloadBuilder
                .suspend()
                .withProcessInstanceId("129663bb-ebe4-11ed-afeb-005056c00008")
                .build());
    }

之前

//激活流程实例
    @Test
    public void resumeProcessInstance() {
        securityUtil.logInAs("bajie");
        ProcessInstance processInstance = processRuntime.resume(ProcessPayloadBuilder
                .resume()
                .withProcessInstanceId("129663bb-ebe4-11ed-afeb-005056c00008")
                .build());
    }

//流程实例参数
    @Test
    public void getVariable(){
        securityUtil.logInAs("bajie");
        List<VariableInstance> list = processRuntime.variables(ProcessPayloadBuilder
                .variables()
                .withProcessInstanceId("a")
                .build());
        for (VariableInstance vi : list){
            System.out.println("-------------");
            System.out.println("Name:"+vi.getName());
            System.out.println("Value:"+vi.getValue());
            System.out.println("TaskId:"+vi.getTaskId());
            System.out.println("ProcessInstance:"+vi.getProcessInstanceId());
        }
    }

排他网关：

TaskRuntime

package com.test.activiti;

import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.model.Task;
import org.activiti.api.task.model.builders.TaskPayloadBuilder;
import org.activiti.api.task.runtime.TaskRuntime;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part9_TaskRuntime {


    @Autowired
    private TaskRuntime taskRuntime;


    @Autowired
    private SecurityUtil securityUtil;


    //获取当前登录用户任务
    @Test
    public void getTask() {
        securityUtil.logInAs("bajie"); //真实情况下没有
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 100));
        List<Task> list = tasks.getContent();
        for (Task tk : list) {
            System.out.println("Id:" + tk.getId());
            System.out.println("Name:" + tk.getName());
            System.out.println("Status:" + tk.getStatus());
            System.out.println("CreatedDate:" + tk.getCreatedDate());
            if (tk.getAssignee() == null) {
                //候选人为当前登录用户，null的时候需要前端拾取
                System.out.println("Assignee: 待拾取任务");
            } else {
                System.out.println("Assignee:" + tk.getAssignee());
            }
        }
    }
}

/*
* taskRuntime.tasks()源码
*/
 public Page<Task> tasks(Pageable pageable) {
        String authenticatedUserId = this.securityManager.getAuthenticatedUserId(); //用到了spring security
        if (authenticatedUserId != null && !authenticatedUserId.isEmpty()) {
            List<String> userGroups = this.userGroupManager.getUserGroups(authenticatedUserId);
            return this.tasks(pageable, TaskPayloadBuilder.tasks().withAssignee(authenticatedUserId).withGroups(userGroups).build());
        } else {
            throw new IllegalStateException("You need an authenticated user to perform a task query");
        }
    }

 //完成任务
    @Test
    public void completeTask() {
        securityUtil.logInAs("bajie"); //真实情况下没有
        Task task = taskRuntime.task("3afd8512-ebe3-11ed-92b6-005056c00008");
        if (task.getAssignee() == null) {
            taskRuntime.claim(TaskPayloadBuilder.claim()
                    .withTaskId(task.getId())
                    .build());
        }
        taskRuntime.complete(TaskPayloadBuilder
                .complete()
                .withTaskId(task.getId())
                .build());
        System.out.println("任务执行完成");
    }

3.10 Spring Security

认证
鉴权、授权

用户三种来源

application.properties 配置用户
代码中配置内存用户
从数据库中加载用户

知识点

内存登陆改为数据库登陆
SpringSecurity 配置文件详解
登录相应处理方案

package com.test.activiti.security;


import com.test.activiti.mapper.UserInfoBeanMapper;
import com.test.activiti.pojo.UserInfoBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;


@Component //变成一个组件
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserInfoBeanMapper userInfoBeanMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//        //写死
//        String password = passwordEncoder().encode("111");
//
//        return new User(username
//                ,password
//                ,AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_ACTIVITI_USER")); //给用户增加角色
//
        //读取数据库判断用户
        //如果用户是null抛出异常
        //返回用户信息

        UserInfoBean userInfoBean = userInfoBeanMapper.selectByUserName(username);
        if (userInfoBean == null) {
            throw new UsernameNotFoundException("数据库中无此用户");
        }
        return userInfoBean;
    }

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

创建实体类：

package com.test.activiti.pojo;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

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

@Component
public class UserInfoBean implements UserDetails {
    private Long id;
    private String name;
    private String username;
    private String password;
    private String address;
    private String roles;

    public String getAddress(){
        return address;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Arrays.stream(roles.split(","))
                .map(s -> new SimpleGrantedAuthority(s))
                        .collect(Collectors.toList());
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

mapper：

package com.test.activiti.mapper;

import com.test.activiti.pojo.UserInfoBean;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

@Mapper
@Component
public interface UserInfoBeanMapper {
    
    @Select("select * from user where username = #{username}")
    UserInfoBean selectByUserName(@Param("username")String username);
}

这里因为之前tomcat用了80端口，因此此项目启动用8081端口启用：

package com.test.activiti.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class ActivitiSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private LoginSuccessHandler loginSuccessHandler;

    @Autowired
    private LoginFailHandler loginFailHandler;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception{
        httpSecurity
                .formLogin()
                //登陆方法
                .loginPage("/login")
                .loginProcessingUrl("/login") //登陆验证之后的处理
                //登陆后
                .successHandler(loginSuccessHandler)
                .failureHandler(loginFailHandler)
                .and()
                .authorizeRequests()
                .anyRequest()
                .permitAll()
                .and()
                .logout()
                .permitAll()
                .and().csrf().disable()
                .headers()
                .frameOptions()
                .disable();
    }
}

登陆成功处理类：

package com.test.activiti.security;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.test.activiti.util.AjaxResponse;
import com.test.activiti.util.GlobalConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component("loginSuccessHandler")
public class LoginSuccessHandler implements AuthenticationSuccessHandler {

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException, ServletException {
        AuthenticationSuccessHandler.super.onAuthenticationSuccess(request, response, chain, authentication);
    }

    @Override //后台从页面拿到什么值 HttpServletRequest 后台向页面输出什么值 HttpServletResponse
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write("登陆成功LoginSuccessHandler");
//        response.getWriter().write("获取登录名："+authentication.getName());

//        response.getWriter().write(objectMapper.writeValueAsString(AjaxResponse.AjaxData(0,"成功",authentication.getName()))
//        );

        response.getWriter().write(
                objectMapper.writeValueAsString(
                        AjaxResponse.AjaxData(
                                GlobalConfig.ResponseCode.SUCCESS.getCode(),
                                GlobalConfig.ResponseCode.SUCCESS.getDesc(),
                                authentication.getName())
        ));
    }
}

这里需要使用接口测试工具来进行测试：

测试登录失败：

package com.test.activiti.security;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.test.activiti.util.AjaxResponse;
import com.test.activiti.util.GlobalConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class LoginFailHandler implements AuthenticationFailureHandler {


    @Autowired
    private ObjectMapper objectMapper;


    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        response.setStatus(500);
        response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());

        response.setContentType("application/json;charset=UTF-8");
//        response.getWriter().write("登陆失败，原因是:"+ exception.getMessage());

        response.getWriter().write(
                objectMapper.writeValueAsString(
                        AjaxResponse.AjaxData(
                                GlobalConfig.ResponseCode.ERROR.getCode(),
                                GlobalConfig.ResponseCode.ERROR.getDesc(),
                                "登陆失败，原因是:"+ exception.getMessage())
                ));

    }
}

3.11 BPMN.js

a. 下载BPMN.js

bpmn：https://bpmn.io/

bpmn download：https://bpmn.io/toolkit/bpmn-js/download/

点击 Explore Examples

i18n可以根据需要修改语言配置

properties-panel可以创建BPMN.js的控制面板

b. 安装Node.js

下载地址https://nodejs.org/en/download/
Node.js安装指导
运行：
- npm install
- npm run dev

可自定义配置

你可能感兴趣的:(Java开发,学习,笔记,java,spring)

【Python】一文详细介绍 py格式文件高斯小哥 Python基础【高质量合集】python 新手入门学习
【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
大学播音主持都学什么内容？播音主持专业学什么？配音新手圈
有些喜欢播音主持并且犹豫要不要报考这个大学专业的小伙伴们就会想要了解大学播音主持都学什么内容吧，毕竟如果不够了解就直接选择这个专业真的等选择完进去学习以后才知道这个专业并不是自己想要学习的东西那就来不及了。下面是小编为大家整理出来的一些播音主持专业学习的内容，请往下看吧。大学播音主持专业主要学习的课程有：播音发声、播音创作基础、广播播音主持、电视播音主持、文艺作品演播学概论、新闻学概论、新闻采编、
新网师的精神肤色（幕布笔记）悦读书香
王子老师的《极简100小妙招》收到已经几天了，之前大概的浏览了全书，今天起给自己定了一个计划，必须每天学习极简小妙招里面的一个妙招，并加以运用。一、今天要打卡什么内容因有完成每天学习极简小妙招的计划，所以今天晚饭吃的比较简单，草草吃完以后带着小宝到广场溜达一圈，急忙赶回来学习极简小妙招。再重看的时候不知道自己要学点什么，打卡哪一招，感觉哪个都简单，就看这一环节像王子老师说的“一看就会”，但做这一环
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
学习JavaEE的日子 Day32 线程池 A 北枝学习JavaEE 学习 java-ee java 线程池
Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
SpringMVC设置全局异常处理器水岸齐天 java spring
文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
没有如释重负君远近
虽然只有短短的一个多月的努力复习时间，但今天的整个考试经过，还是发现了效果的，题目做的比较自如，没有慌里慌张，而且提前五分钟完成。至于考试成绩，没有实足的把握，60分都不敢保证。但绝对相信自己，比去年肯定要好！今天早早的赶到考场，见到了刘老师，谈起来学习情况，坦率的说，真的是自己不够重视。总以为会很难，没有信心。其实不是的，只要认真对待，树立足够的信心，绝对可以通过考试的。还向老师询问了，后续再报
C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】还算善良_ 私有代码库工具类 java list 数据结构
packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
心赏（2018.10.8）六一节_3928
1.上班第一天，同事彤休完产假，回来上班，给我带了酸奶和水果。她生小孩时，我给她发了一个小红包贺喜，哪知她就记在心里了。心赏这个有心的90后。2.女儿放学回来，说自己当了小组长。一边说不想当，一边得意的样子。心赏老师给了孩子这个锻炼的机会。3.老妈今天做了"蚂蚁上树"的菜，得到女儿的高度肯定。心赏老妈还在不断学习。
springboot集成logback-spring.xml文件 RT_0114 SpringBoot spring boot spring logback
彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
2022-2-13晨间日记越亮也打烊
今天是什么日子起床：7:00就寝：12:08天气：晴心情：糟糕纪念日：无任务清单昨日完成的任务，最重要的三件事：寒假作业，网课，画画改进：作业时间剪短习惯养成：网课不逃～周目标·完成进度数学卷子100％学习·信息·阅读《傅雷家书》《钢铁是怎样炼成的》健康·饮食·锻炼我终于不喝饮料啦，喝茶～人际·家人·朋友邝姐姐带我吃火锅工作·思考啥时候开学，我还有几天赶完作业最美好的三件事1.卷子写完了2.我有冰
中原焦点团队38期王芳芳坚持分享第236天，20230630总约练134次，来访113次，咨8次，观察员13次芳芳王
学习焦点的初心是想拯救孩子，孩子由于沉迷游戏，成绩下滑，在学习的过程中发现是自己的教育方式出了状况。经过半年的学习，一些焦点的基本技巧，如接纳、欣赏、倾听、同理心、尊重等都有了一定的了解。但在实际应用时仍然存在很多问题，感觉自己仍然没有放下对孩子成绩的期望，仍然把握不住对孩子管理的度。我该如何去陪伴好孩子？多用心去听课，并加强反思，多约练。去思考如何让自己快乐起来？
请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shiro java java 安全开发语言
请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？大龄下岗程序员 mysql java mysql spring
Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
大创项目推荐深度学习 opencv python 公式识别(图像识别机器视觉) laafeer python
文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
#D174-读书会作业-《财务自由之路》3 白洲笔记
最近沉迷于写作营，一直就没时间去弄读书会的作业，书的第二遍也就看了个开头，趁着日更的时间，赶紧把作业做了，这次是15到21课。【1.印象最深刻的部分】(本周所读内容中印象最深刻的部分)*活在未来，最正确的方法是什么？用正确的方法做正确的事情，判断什么是正确的？逻辑。学会思考。"作对事情"永远比“把事情作对“重要的多。”长远思考，耐心验证，小心总结提炼“证明自己正确并不是学习的任务和目标，时刻成长，
读书笔记《穿越寒冬》如雪般飞舞
各位好，我们今天来讲一本书，名字叫作《穿越寒冬》。看起来特别应景，大家觉得现在创业的状况不景气，大家都在忍受着寒冬的煎熬。但实际上，这本书的英文名字并不是这个意思，它的英文名叫作“如何创立一家新公司，并且能够活下来”。我在整个读完了以后，我发现这本书真正要翻译得好，它的名字应该叫作《创业生存手册》。这个书的作者，来自硅谷的霍夫曼船长。霍夫曼船长写过一本让创业者觉得特别贴心的书，叫作《让大象飞》它和
3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb 前端 ajax elementui java 前端框架
P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
账务处理又出错？资深会计来教你，学会效率翻倍！共同学习小橘子要努力吖
作为一名会计，在实际工作中会遇到各种麻烦的账务处理问题。那么，最常用的会计处理方法都有哪些呢？今天小编为大家带来了从业二十六年的资深老会计分享的十四中会计常用的账务处理问题的解决方案，快来看看吧！一、促销品的账务处理在促销时公司经常会把一些商品按进价赠送给消费者使用二、款已付清但发票未到的账务处理三、购买材料发生不合理损耗的账务处理问题公司在购买材料时，常常会发生一些不合理的损耗，那么这种问题该怎
【真诚子】通晓鬼谷第七篇读书日记。真诚子l通晓鬼谷
今天把个人品牌，从193读到208页，书的内容质量出奇的高，尤其是这一段。对标学习法，找一个比自己强，或者你期望成为的人进行模仿性学习，对标学习，不是到处，去找人对标兵学习很多人的优点，或是学习自己认为好的方面，而是找准一个对标高手，然后全方位的学习这个人。我在做品牌咨询时就对标，学习了一个在国内很有名的行业顶尖大咖。我先找到他公司的方案，进行完全模仿，连PPT的排版都一样，而且我只参照他一个人的
ES-LTR粗排模块 poins jenkins 运维
ES-LTR粗排模块官方资源：https://github.com/HeiBoWang/elasticsearch-learning-to-rankElasticsearch学习排名插件使用机器学习提高搜索相关性排名。它为维基媒体基金会和Snagajob等地方的搜索提供了动力！这个插件有什么功能此插件：允许您在Elasticsearch中存储特征（Elasticsearch查询模板）记录特征得分（
2018-11-18成长小组学习笔记实验中学45
因为嗓子“罢工”，我面对众人只能借“微笑”代言。在开始授课前，绣霞老师先反馈上次作业的情况，提到“接纳”需是真正发自内心的完全接纳，而不是口头上的接纳，内心却是排斥的。提到一个“问题”孩子恰恰对家爱的更加“深沉”，夫妻间的问题不能影响到孩子，对孩子更好的爱不是你为他做的更多，而是给他自由、健康成长的空间。图片发自App一、孩子：家庭的一面镜子夫妻成了彼此的“投射”，婚姻便“吵的不可开交”，婚姻便成
eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ide eclipse java
报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
【鸿蒙HarmonyOS开发笔记】ArkUI常用组件介绍汇总（更新中）温、鸿蒙HarmonyOS开发笔记学习记录 harmonyos 笔记华为
概述此文总结开发中用到的一些常用组件，便于查阅，此文持续更新，闲的没事就更线性布局（Row/Column）不多介绍了，最常用的布局组件，两者除了方向不一样，别的都一样方便起见下面只写Column常用属性排列方向上的间距：spaceColumn({space:20}){Row().width('90%').height(50).backgroundColor(0xF5DEB3)Row().width
2019-07-16 振华老凤祥店长崔宁宁
大爱的李老师，智慧的教授，亲爱的跃友们：大家好！我是莱州鑫和金店李总的人～崔宁宁今天是我的日精进行动第56天，我分享一下今天的改变，我们相互勉励，每天进步一点点，离成功便不远。1、比学习：人这一生最主要的就是信念，坚定不移的信念是成功路上的重要基石！2、比改变：我是一切的根源，我变了世界就变了！改变自己的心态！3、比付出：承担才能成长，付出才会杰出！4、比谦卑：学习每位优秀店长身上的优点！5、比感
python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
2018-12-02 子分小
姓名：张颖公司：菲尔德国际英语【反省总结第146天，始于20180709今天是20181202】【知～学习】六项精进大纲背诵3遍每天十个单词坚持第181天每天学习一篇英文文章第94天英语流利说课程第71天学习30分钟【行～实践】一、修身：（对自己个人）步行5000步二、齐家：（对家庭和家人）无三、建功：（对工作)完成与Arti活动课和两节Demo准备开班事宜｛积善｝：发愿从2018年7月9日起1年
安卓笔记本 - Handler Message MessageQueue Looper SocialException
不爱写字，一张图解决。Handler,Message,MessageQueue,Looper工作原理
枚举使用笔记万变不离其宗_8 项目笔记笔记
1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
log4j对象改变日志级别 3213213333332132 java log4j level log4j对象名称日志级别
log4j对象改变日志级别可批量的改变所有级别，或是根据条件改变日志级别。 log4j配置文件： log4j.rootLogger=ERROR,FILE,CONSOLE,EXECPTION #log4j.appender.FILE=org.apache.log4j.RollingFileAppender log4j.appender.FILE=org.apache.l
elk+redis 搭建nginx日志分析平台 ronin47 elasticsearch kibana logstash
elk+redis 搭建nginx日志分析平台 logstash,elasticsearch,kibana 怎么进行nginx的日志分析呢？首先，架构方面，nginx是有日志文件的，它的每个请求的状态等都有日志文件进行记录。其次，需要有个队列，redis的l
Yii2设置时区 dcj3sjt126com PHP timezone yii2
时区这东西，在开发的时候，你说重要吧，也还好，毕竟没它也能正常运行，你说不重要吧，那就纠结了。特别是linux系统，都TMD差上几小时，你能不痛苦吗？win还好一点。有一些常规方法，是大家目前都在采用的1、php.ini中的设置，这个就不谈了，2、程序中公用文件里设置，date_default_timezone_set一下时区3、或者。。。自己写时间处理函数，在遇到时间的时候，用这个函数处理（比较
js实现前台动态添加文本框，后台获取文本框内容 171815164 文本框
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://w
持续集成工具 g21121 持续集成
持续集成是什么？我们为什么需要持续集成？持续集成带来的好处是什么？什么样的项目需要持续集成？... 持续集成(Continuous integration ,简称CI)，所谓集成可以理解为将互相依赖的工程或模块合并成一个能单独运行
数据结构哈希表(hash)总结永夜-极光数据结构
1.什么是hash 来源于百度百科: Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
乱七八糟程序员是怎么炼成的
eclipse中的jvm字节码查看插件地址： http://andrei.gmxhome.de/eclipse/ 安装该地址的outline 插件后重启，打开window下的view下的bytecode视图 http://andrei.gmxhome.de/eclipse/ jvm博客： http://yunshen0909.iteye.com/blog/2
职场人伤害了“上司” 怎样弥补 aijuans 职场
由于工作中的失误，或者平时不注意自己的言行“伤害”、“得罪”了自己的上司，怎么办呢？　　在职业生涯中这种问题尽量不要发生。下面提供了一些解决问题的建议：　　一、利用一些轻松的场合表示对他的尊重　　即使是开明的上司也很注重自己的权威，都希望得到下属的尊重，所以当你与上司冲突后，最好让不愉快成为过去，你不妨在一些轻松的场合，比如会餐、联谊活动等，向上司问个好，敬下酒，表示你对对方的尊重，
深入浅出url编码 antonyup_2006 应用服务器浏览器 servlet weblogic IE
出处：http://blog.csdn.net/yzhz 杨争 http://blog.csdn.net/yzhz/archive/2007/07/03/1676796.aspx 一、问题：编码问题是JAVA初学者在web开发过程中经常会遇到问题，网上也有大量相关的
建表后创建表的约束关系和增加表的字段百合不是茶标的约束关系增加表的字段
下面所有的操作都是在表建立后操作的,主要目的就是熟悉sql的约束,约束语句的万能公式 1,增加字段(student表中增加姓名字段) alter table 增加字段的表名 add 增加的字段名增加字段的数据类型 alter table student add name varchar2(10); &nb
Uploadify 3.2 参数属性、事件、方法函数详解 bijian1013 JavaScript uploadify
一.属性属性名称默认值说明 auto true 设置为true当选择文件后就直接上传了，为false需要点击上传按钮才上传。 buttonClass ” 按钮样式 buttonCursor ‘hand’ 鼠标指针悬停在按钮上的样子 buttonImage null 浏览按钮的图片的路
精通Oracle10编程SQL(16)使用LOB对象 bijian1013 oracle 数据库 plsql
/* *使用LOB对象 */ --LOB(Large Object)是专门用于处理大对象的一种数据类型，其所存放的数据长度可以达到4G字节 --CLOB/NCLOB用于存储大批量字符数据，BLOB用于存储大批量二进制数据，而BFILE则存储着指向OS文件的指针 /* *综合实例 */ --建立表空间 --#指定区尺寸为128k,如不指定，区尺寸默认为64k CR
【Resin一】Resin服务器部署web应用 bit1129 resin
工作中，在Resin服务器上部署web应用，通常有如下三种方式：配置多个web-app 配置多个http id 为每个应用配置一个propeties、xml以及sh脚本文件配置多个web-app 在resin.xml中,可以为一个host配置多个web-app <cluster id="app&q
red5简介及基础知识白糖_ 基础
简介 Red5的主要功能和Macromedia公司的FMS类似，提供基于Flash的流媒体服务的一款基于Java的开源流媒体服务器。它由Java语言编写，使用RTMP作为流媒体传输协议，这与FMS完全兼容。它具有流化FLV、MP3文件，实时录制客户端流为FLV文件，共享对象，实时视频播放、Remoting等功能。用Red5替换FMS后,客户端不用更改可正
angular.fromJson boyitech AngularJS AngularJS 官方API AngularJS API
angular.fromJson 描述: 把Json字符串转为对象使用方法: angular.fromJson(json); 参数详解: Param Type Details json string JSON 字符串返回值: 对象, 数组, 字符串或者是一个数字示例: <!DOCTYPE HTML> <h
java-颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I bylijinnan java
public class ReverseWords { /** * 题目：颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I.词以空格分隔。 * 要求： * 1.实现速度最快,移动最少 * 2.不能使用String的方法如split,indexOf等等。 * 解答：两次翻转。 */ publ
web实时通讯 Chen.H Web 浏览器 socket 脚本
关于web实时通讯，做一些监控软件。由web服务器组件从消息服务器订阅实时数据，并建立消息服务器到所述web服务器之间的连接，web浏览器利用从所述web服务器下载到web页面的客户端代理与web服务器组件之间的socket连接，建立web浏览器与web服务器之间的持久连接；利用所述客户端代理与web浏览器页面之间的信息交互实现页面本地更新，建立一条从消息服务器到web浏览器页面之间的消息通路
[基因与生物]远古生物的基因可以嫁接到现代生物基因组中吗? comsci 生物
大家仅仅把我说的事情当作一个IT行业的笑话来听吧..没有其它更多的意思如果我们把大自然看成是一位伟大的程序员,专门为地球上的生态系统编制基因代码,并创造出各种不同的生物来,那么6500万年前的程序员开发的代码,是否兼容现代派的程序员的代码和架构呢?
oracle 外部表 daizj oracle 外部表 external tables
oracle外部表是只允许只读访问，不能进行DML操作，不能创建索引，可以对外部表进行的查询，连接，排序，创建视图和创建同义词操作。 you can select, join, or sort external table data. You can also create views and synonyms for external tables. Ho
aop相关的概念及配置 daysinsun AOP
切面(Aspect): 通常在目标方法执行前后需要执行的方法（如事务、日志、权限），这些方法我们封装到一个类里面，这个类就叫切面。连接点（joinpoint） spring里面的连接点指需要切入的方法，通常这个joinpoint可以作为一个参数传入到切面的方法里面（非常有用的一个东西）。通知（Advice）通知就是切面里面方法的具体实现，分为前置、后置、最终、异常环
初一上学期难记忆单词背诵第二课 dcj3sjt126com english word
middle 中间的，中级的 well 喔，那么；好吧 phone 电话，电话机 policeman 警察 ask 问 take 拿到；带到 address 地址 glad 高兴的，乐意的 why 为什么 China 中国 family 家庭 grandmother (外)祖母 grandfather (外)祖父 wife 妻子 husband 丈夫 da
Linux日志分析常用命令 dcj3sjt126com linux log
1.查看文件内容 cat -n 显示行号 2.分页显示 more Enter 显示下一行空格显示下一页 F 显示下一屏 B 显示上一屏 less /get 查询"get"字符串并高亮显示 3.显示文件尾 tail -f 不退出持续显示 -n 显示文件最后n行 4.显示头文件 head -n 显示文件开始n行 5.内容排序 sort -n 按照
JSONP 原理分析 fantasy2005 JavaScript jsonp jsonp 跨域
转自 http://www.nowamagic.net/librarys/veda/detail/224 JavaScript是一种在Web开发中经常使用的前端动态脚本技术。在JavaScript中，有一个很重要的安全性限制，被称为“Same-Origin Policy”（同源策略）。这一策略对于JavaScript代码能够访问的页面内容做了很重要的限制，即JavaScript只能访问与包含它的
使用connect by进行级联查询 234390216 oracle 查询父子 Connect by 级联
使用connect by进行级联查询 connect by可以用于级联查询，常用于对具有树状结构的记录查询某一节点的所有子孙节点或所有祖辈节点。来看一个示例，现假设我们拥有一个菜单表t_menu，其中只有三个字段：
一个不错的能将HTML表格导出为excel,pdf等的jquery插件 jackyrong jquery插件
发现一个老外写的不错的jquery插件，可以实现将HTML 表格导出为excel,pdf等格式，地址在： https://github.com/kayalshri/ 下面看个例子，实现导出表格到excel,pdf <html> <head> <title>Export html table to excel an
UI设计中我们为什么需要设计动效 lampcy UI UI设计
关于Unity3D中的Shader的知识首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，
如何禁止页面缓存 nannan408 html jsp cache
禁止页面使用缓存~ ------------------------------------------------ jsp:页面no cache： response.setHeader("Pragma","No-cache"); response.setHeader("Cache-Control","no-cach
以代码的方式管理quartz定时任务的暂停、重启、删除、添加等 Everyday都不同定时任务管理 spring-quartz
【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的 “暂停” 呢？暂停之后又要在某个时间点 “重启” 该定时任务呢？或者说直接 “删除” 该定时任务呢？要改变某定时任务的触发时间呢？ “添加” 一个定时任务对于系统的使用者而言，是不太现实的，因为一个定时任务的处理逻辑他是不
EXT实例 tntxia ext
（1）增加一个按钮 JSP: <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); Stri
数学学习在计算机研究领域的作用和重要性 xjnine Math
最近一直有师弟师妹和朋友问我数学和研究的关系，研一要去学什么数学课。毕竟在清华，衡量一个研究生最重要的指标之一就是paper,而没有数学，是肯定上不了世界顶级的期刊和会议的，这在计算机学界尤其重要！你会发现，不论哪个领域有价值的东西，都一定离不开数学！在这样一个信息时代，当google已经让世界没有秘密的时候，一种卓越的数学思维，绝对可以成为你的核心竞争力. 无奈本人实在见地

Activiti 工作流 学习笔记