微信精选文章

中国何时能成为“超级大国”？

为什么建议年轻人不要买房？

房产和投资理财，哪个更好？

养鹅——才能实现财务自由

更多文章请微信搜索“灯塔量化”公众号，跟我一起学习投资理财知识！

一、Activiti表单

1
2
3
4
5
6
7
8

<startEvent id="startevent1" name="Start">
    <extensionElements>
        <activiti:formProperty id="userName" name="userName"
            variable="userName" type="string" />
        <activiti:formProperty id="age" name="age"
            variable="age" type="string" />
    </extensionElements>
</startEvent>

1
2
3
4
5
6
7
8
9
10
11
12
13

FormService formService = engine.getFormService();
StartFormData sfd = formService.getStartFormData(pd.getId());
List<FormProperty> formProps = sfd.getFormProperties();
Map<String, Object> variables = Maps.newHashMap();
for(FormProperty fp : formProps) {
    System.out.println(fp.getName() + "--" + fp.getType());
	if (StringFormType.class.isInstance(formProperty.getType())) {
		variables.put(formProperty.getId(), "1");
	} else if (DateFormType.class.isInstance(formProperty.getType())) {
		variables.put(formProperty.getId(), "1");
	}
	taskService.complete(task.getId(), variables);
}

执行任务

1
2

//这样也会执行任务到下一个任务节点
proccessEngine.getFormService().submitTaskFormData(task.getId(),map);

二、事件监听

配置监听

activiti.cfg.xml配置文件添加配置：
添加一个bean实现ActivitiEventListener接口
根据ActivitiEventType枚举判断监听的类型

程序添加
runtimeService.addEventListener(new MyEventListenner());

主动触发监听自定义类型

runtimeService.dispatchEvent(new ActivitiEventImpl(ActivitiEventType.CUSTOM));

会签

利用多实例，实现多个审核通过

其他

taskAssignee 优先 taskCandidateGroup
delegate > setAssignee > claim 后两者都是设置Assignee(代理人)，设置claim时，存在就会抛出异常不会设置成功

一、activiti配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">  
  <!-- spring模式加载的class不同 -->
  <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">  
  
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db_activiti" />
    <!-- 数据库配置也可以直接用数据源dataSource注入 -->
    <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />  
    <property name="jdbcUsername" value="root" />  
    <property name="jdbcPassword" value="root" />  
    <!-- false:关闭；true:当表不存在时自动创建；create-drop/drop-create -->
    <property name="databaseSchemaUpdate" value="true" />  
    <!-- 监控流程作业，默认false -->
    <property name="jobExecutorActivate" value="false" />
    <!--
        none: 跳过所有的历史数据。性能最优，但是没有历史数据。
        activity: 保存所有的流程实例和活动信息。只保留最后信息，没有明细信息。
        audit: 默认级别。保存所有的流程实例，任务、活动、表单属性等信息。
        full: 最高级别，最完整的的历史信息。除了audit中的信息外，还包含详细信息。
    -->
    <property name="history" value="audit" />
    <!-- 打开异步处理Service任务 -->
    <property name="asyncExecutorActivate" value="true"></property>
    <!-- 发布流程不生成流程图 -->
    <property name="createDiagramOnDeploy" value="false" />
    <!-- 字体 -->
    <property name="activityFontName" value="宋体" />
	<property name="labelFontName" value="宋体" />
	<!-- 不保存流程图片 -->
	<property name="createDiagramOnDeploy" value="false" />
	
	<property name="DbIdentityUsed" value="true" />
	<property name="DbHistoryUsed" value="true" />
	<property name="databaseTablePrefix" value="T_" />
	<property name="databaseType" value="mysql" />
  </bean>  
  
</beans>

二、数据库表

参考：Activiti数据库表结构(表详细版)

activiti6.0新增：

• ACT_RU_TIMER_JOB 存放定时任务
• ACT_RU_SUSPENDED_JOB 存放暂停任务
• ACT_RU_DEADLETTER_JOB 无法执行的任务
• ACT_EVT_LOG 异步日志表
• ACT_PROCDEF_INFO 流程定义扩展表

三、service接口

• RepositoryService

  流程仓库Service，用于管理流程仓库，如部署、删除、读取流程资源。

• IdentifyService

  身份Service，管理和查询用户、组之间的关系。

• RuntimeService

  运行时Service，管理所有正在运行状态的流程实例、任务等。

• TaskService

  任务Service，用于管理、查询任务，如签收、办理、指派等。

• FormService

  表单Service，用于读取和流程、任务相关的表单数据。

• HistoryService

  历史Service，可以查询所有历史数据。

• ManagementService

  引擎管理Service，和具体业务无关，主要是可以查询引擎配置、数据库、作业等。

7个service都是通过ProcessEngine对象来获取的

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

四、activiti流程设计器使用（BPMN2.0规范）

事件

1、事件的分类与定义

• 定时器事件定义

  可以用在开始事件、中间事件、边界事件。可选指定时间触发、循环触发。支持cron表达式

• 错误事件定义

  可以用在开始事件、结束事件、边界事件。捕获/抛出错误。

• 信号事件定义

  通过一个信号控制多个流程实例，可以用在边界事件、中间事件。

• 消息事件定义

  一个消息控制一个流程实例

• 取消事件定义

  用在事务子流程模型中，有取消边界事件和取消结束事件

• 补偿事件定义

  补偿事件

• 其他事件

2、开始事件

• 无指定开始事件

• 定时器开始事件

  必须在配置文件打开异步处理Service任务，可以设置定时器触发方式

• 消息开始事件

  通过消息名称启动流程：
  ProcessInstance pi = runService.startProcessInstanceByMessage(“msgName”);
  流程配置文件添加<message id="msgA" name="msgName"></message>

• 错误开始事件

  流程中抛出异常，在事件子流程开始错误事件中捕获异常
  流程配置文件添加<error id="countError" errorCode="abc"></error>
  处理类抛出throw new org.activiti.engine.delegate.BpmnError("abc");

3、结束事件

• 无指定结束事件

• 错误结束事件

  流程以错误事件结束，然后事务子流程中就会捕获，从而执行子流程。或者触发边界错误捕获流程。

• 取消结束事件

  在事务子流程中，触发取消结束事件后，就会触发所有补偿边界事件，然后先执行补偿边界事件，再判断整个事务子流程中是否有边界事件，有就执行事务子流程中的。

  1 2 3 4

  <endEvent id="cancelendevent1" name="CancelEnd"> <cancelEventDefinition></cancelEventDefinition> </endEvent> >

• 终止结束事件

  当一个流程实例中，有多个任务都可以执行（并行网关），有一条执行到了终止结束事件，那么整个流程实例都终止了。

4、边界事件

• 定时器边界事件

  当触发定时器时，执行定时器指定的任务

• 错误边界事件

  捕获异常：throw new org.activiti.engine.delegate.BpmnError("abc");

• 信号边界事件

  ，当执行到某个节点的时候触发信号或者消息时，执行另一个任务。申请–>审批–>审批不通过触发事件–>回到申请

• 取消边界事件

  当事务子流程中，取消结束事件被触发后，补偿边界事件触发，然后子流程取消边界事件也会触发

• 补偿边界事件

  1 2 3 4

  <boundaryEvent id="boundarycompensation1" name="Compensate" attachedToRef="usertask1" cancelActivity="true"> <compensateEventDefinition></compensateEventDefinition> </boundaryEvent> >

5、中间事件

• 定时器中间事件（捕获）

  必须等待定时器触发后才能执行后面的节点任务（下个节点延迟拿到执行）

  1 2 3 4 5 6

  <intermediateCatchEvent id="timerintermediatecatchevent1" name="TimerCatchEvent"> <timerEventDefinition> <timeDuration>PT5S</timeDuration> </timerEventDefinition> </intermediateCatchEvent>

>

• 信号中间事件（捕获和抛出）

  比如并行网关里，多条执行任务都是捕获信号中间事件，然后其中一条任务执行完成后，抛出信号中间事件，其他有捕获信号中间时间的执行任务才能往下走。(中间信号事件是自动触发的)

  1 2 3 4 5 6 7 8 9 10 11

  <signal id="finishPay" name="finishPay"></signal> <!-- 捕获 --> <intermediateThrowEvent id="signalintermediatethrowevent1" name="SignalThrowEvent"> <signalEventDefinition signalRef="finishPay"></signalEventDefinition> </intermediateThrowEvent> <!-- 抛出 --> <intermediateCatchEvent id="signalintermediatecatchevent2" name="SignalCatchEvent"> <signalEventDefinition signalRef="finishPay"></signalEventDefinition> </intermediateCatchEvent> >

• 消息中间事件（捕获）

1 2 3 4

Execution run = runService.createExecutionQuery().messageEventSubscriptionName("message").singleResult(); System.out.println(run.getId()); runService.messageEventReceived("message", run.getId()); >

• 信号中间事件

1 2 3 4 5 6 7 8 9

// 启动流程 ProcessInstance pi = runService.startProcessInstanceById(pd.getId()); // 查当前的子执行流（只有一个） Execution exe = runService.createExecutionQuery() .processInstanceId(pi.getId()).onlyChildExecutions() .singleResult(); System.out.println(pi.getId() + ", 当前节点：" + exe.getActivityId()); runService.signalEventReceived("testSignal"); >

• 补偿中间事件

6、补偿事件

补偿边界事件

• 事务子流程有取消结束事件就会执行子流程中补偿边界事件
• 触发补偿中间事件==>触发边界补偿事件

补偿中间事件

触发补偿中间事件就会触发所有之前任务的边界补偿事件

任务

1、用户任务

• 分配任务的候选人

  • 方式1：使用taskService的addCandidateGroup和addCandidateUser方法
  • 方式2：使用XML配置

    1 2 3 4 5 6 7

    <potentialOwner> <resourceAssignmentExpression> <formalExpression>user(angus), group(management), boss </formalExpression> </resourceAssignmentExpression> </potentialOwner> </userTask>

• 分配任务代理人
  一个任务可以分配多个候选人，但是只能有一个代理人

  • 方式1：使用task对象的setAssignee方法设置代理人
  • 方式2：使用XML配置

    1 2 3 4 5 6

    <humanPerformer> <resourceAssignmentExpression> <formalExpression>user</formalExpression> </resourceAssignmentExpression> </humanPerformer> > </userTask>

• 权限分配扩展

  1 2 3 4

  <userTask id="usertask1" name="Task A" activiti:assignee="user1" activiti:candidateUsers="angus,angus1" activiti:candidateGroups="boss,management"> </userTask> >

当设置代理人的时候，该任务只属于该代理人

• 使用任务监听器进行权限分配

  见监听器

• 使用JUEL分配权限

  1 2 3 4

  <userTask id="usertask1" name="My Task" activiti:candidateUsers="${authService.getCandidateUsers()}" activiti:candidateGroups="${authService.getCandidateGroups()}" activiti:assignee="${authService.getAssignee()}" ></userTask> >

启动流程：

1 2 3 4

Map<String, Object> vars = new HashMap<String, Object>(); vars.put("authService", new AuthService()); ProcessInstance pi = runService.startProcessInstanceById(pd.getId(), vars); >

AuthService类中方法返回List<String>获取String类型即可

2、服务任务

• Java Service Task

  • activiti:class：必须是该两个接口的实现类JavaDelegate、ActivityBehavior

    必须写死类路径

  • activiti:delegateExpression

    activiti:delegateExpression="${myDelegate}"

    1 2 3 4 5 6 7

    //MyDelegate实现JavaDelegate和Serializable MyDelegate de = new MyDelegate(); Map<String ,Object> vars = new HashMap<String, Object>(); vars.put("myDelegate", de); // 启动流程 ProcessInstance pi = runService.startProcessInstanceById(pd.getId(), vars); >

  • activiti:expression

    activiti:expression="${myBean.print(execution)}"
activiti:expression="${execution.setVariable('myName', myBean.name)}"

    1 2 3 4 5 6

    Map<String ,Object> vars = new HashMap<String, Object>(); //print方法传入Execution exe，可以获取当前的任务 vars.put("myBean", new MyBean());//实现Serializable接口，并且有name成员变量，getName方法 // 启动流程 ProcessInstance pi = runService.startProcessInstanceById(pd.getId(), vars); >

JavaDelegate 会自动执行，ActivityBehavior 会等待

• Shell Task

  1 2 3 4 5 6 7 8 9 10

  <serviceTask id="servicetask1" name="Service Task" activiti:type="shell"> <extensionElements> <activiti:field name="command" stringValue="cmd"/> <activiti:field name="arg1" stringValue="/c"/> <activiti:field name="arg2" stringValue="echo"/> <activiti:field name="arg3" stringValue="%JAVA_HOME%"/> <activiti:field name="outputVariable" stringValue="javaHome"/> </extensionElements> </serviceTask> >

获取参数值runService.getVariable(pi.getId(), "javaHome")

• Receive Task

1 2 3 4 5 6 7 8 9 10

// 启动流程 ProcessInstance pi = runService.startProcessInstanceById(pd.getId()); // 查当前的子执行流（只有一个） Execution exe = runService.createExecutionQuery() .processInstanceId(pi.getId()).onlyChildExecutions() .singleResult(); System.out.println(pi.getId() + ", 当前节点：" + exe.getActivityId()); // 让它往前走 runService.trigger(exe.getId()); >

• Web Service Task

  用不上

  3、其他任务与流程监听器

  其他任务

• 手工任务

  自己会执行，会记录历史数据

• 接收任务: RuntimeService.trigger(exe.getId())
• 邮件任务

  自动发送邮件

• Mule任务
• 业务规则任务

任务监听器

同Service Task有三种配置方式：

• class
• delegateExpression
• expression

监听器触发：

• create

  流程创建时

• assignment

  流程任务分配

• complete

  任务完成

1
2
3
4
5
6
7
8
9
10

<userTask id="usertask1" name="User Task" activiti:assignee="crazyit">
    <extensionElements>
        <activiti:taskListener event="create"
 class="org.crazyit.act.c10.MyTaskListener">
    <activiti:field name="userName" stringValue="crazyit" /></activiti:taskListener>
        <activiti:taskListener event="assignment"
 class="org.crazyit.act.c10.TaskListenerAssignment"></activiti:taskListener>
        <activiti:taskListener event="complete" class="org.crazyit.act.c10.TaskListenerComplete"></activiti:taskListener>
    </extensionElements>
</userTask>

监听器也可以获取流程中设置的参数
监听器实现TaskListener接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class MyTaskListener implements TaskListener {

    private FixedValue userName;
 
    public void setUserName(FixedValue userName) {
        this.userName = userName;
    }

    @Override
    public void notify(DelegateTask arg0) {
        System.out.println("这是自定义任务监听器, " + userName.getExpressionText());
    }

}

流程监听器
监听器触发：

• start

  流程开始

• take

  流程经过

• end

  流程完成

1
2
3
4
5
6
7
8
9
10
11

<extensionElements>
	<activiti:executionListener event="start"
		class="org.crazyit.act.c10.ExecutionListener">
		<activiti:field name="userName" stringValue="crazyit" />
	</activiti:executionListener>
	<activiti:executionListener event="take"
		class="org.crazyit.act.c10.ExecutionListenerAssignment"></activiti:executionListener>
	<activiti:executionListener event="end"
		class="org.crazyit.act.c10.ExecutionListenerComplete">
		</activiti:executionListener>
</extensionElements>

监听器实现类是ExecutionListener

流程网关其他

1、子流程

• 嵌入式子流程

  子流程与外部任务交互必须经过边界事件

• 调用式子流程
  调用外部流程

  添加callActivity节点，指定外部流程ID：SubProcess<callActivity id="callactivity1" name="调用其他的流程" calledElement="SubProcess"></callActivity>
  获取外部流程的实例：ProcessInstance piSub = runService.createProcessInstanceQuery(). superProcessInstanceId(pi.getId()).singleResult();
  传递参数：

  1 2 3 4 5

  <extensionElements> <activiti:in source="days" target="newDays"/> <activiti:out source="myDays" target="resultDays"/> </extensionElements> >

• 事件子流程

  可以由错误、信号、消息、定时器事件触发

• 事务子流程

  在事务子流程中出现异常，子流程边界错误事件会捕捉到。事务子流程中出现取消结束流程，会触发之前的流程任务的边界补偿事务，同时触发子流程取消边界事务

• 特别子流程

  6.0 新增，在该子流程中，不存在执行顺序，由执行时决定

2、顺序流与网关

条件顺序流

1
2
3
4

<sequenceFlow id="flow3" sourceRef="exclusivegateway1" targetRef="usertask2">
    <conditionExpression xsi:type="tFormalExpression">
    <![CDATA[${days <= 3 || day == 5}]]></conditionExpression>
    </sequenceFlow>

如果是条件网关的话，不满足条件会报错。多条满足，会默认走第一个
普通顺序流

一个任务不能出现多条普通顺序流吧

网关

• 单向网关
  与条件顺序流一起使用，只能有一个条件通过

• 并行网关

• 兼容网关
  单向网关和并行网关结合体

• 事件网关
  和中间事务结合使用，多个任务的时候，哪个任务先触发就执行哪条任务
• 组合网关
  不支持

3、流程活动的特性

• 多实例流程活动

  创建多个任务实例

  1 2 3 4 5 6 7

  <serviceTask id="servicetask1" name="Service Task" activiti:class="org.crazyit.act.c10.ForeachDelegate"> <multiInstanceLoopCharacteristics isSequential="false"> <loopCardinality>3</loopCardinality> </multiInstanceLoopCharacteristics> </serviceTask> >

• 设置循环数据（6.0版本）

  1 2 3 4

  Map<String, Object> vars = new HashMap<String, Object>(); vars.put("datas1", datas1); //List<String>格式 ProcessInstance pi = runService.startProcessInstanceById(pd.getId(), vars); >

1 2 3 4 5 6

<serviceTask id="servicetask1" name="Service Task" activiti:class="org.crazyit.act.c10.ForeachDelegate"> <multiInstanceLoopCharacteristics isSequential="false" activiti:elementVariable="data"> <loopDataInputRef>datas1</loopDataInputRef> </multiInstanceLoopCharacteristics> </serviceTask> >

1 2 3 4 5 6 7 8

//处理类，List集合有多少个元素就执行几次 public class ForeachDelegate implements JavaDelegate { @Override public void execute(DelegateExecution execution) { System.out.println("执行服务任务: " + execution.getVariable("data")); } } >

设置了循环了数据，会有内置参数，例如nrOfCompletedInstances是当前执行的实例数
添加<completionCondition>${nrOfCompletedInstances >= 2}</completionCondition>设置条件执行流程

Activiti与BPMN2.0规范

五、流程启动与服务调用API

1、查询

查询所有
通过service获取，各个service查询类似。
service.createGroupQuery().groupName("Group_1").groupType("TYPE_1").list();
分页查询
service.createGroupQuery().listPage(1, 5)
查询单个
service.createGroupQuery().groupName("Group_0").singleResult();
排序
service.createGroupQuery().orderByGroupId().desc().orderByGroupName().asc().list()
自定义查询
service.createNativeGroupQuery(). sql("SELECT * FROM ACT_ID_GROUP where NAME_ = #{name}"). parameter("name", "Group_2").list();
保存
service.newGroup(id); //新增一个执行ID值

###2、流程部署
ZIP

1
2
3
4

FileInputStream fis = new FileInputStream(new File("resource/datas.zip"));
ZipInputStream zis = new ZipInputStream(fis);
builder.addZipInputStream(zis);
builder.deploy();

代码生成流程模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public static void main(String[] args) {
    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    // 存储服务
    RepositoryService rs = engine.getRepositoryService();
    RuntimeService run = engine.getRuntimeService();
    
    DeploymentBuilder builder = rs.createDeployment();
    builder.addBpmnModel("My Process", createProcessModel());
    
    Deployment dep = builder.deploy();
    
}

private static BpmnModel createProcessModel() {
    // 创建BPMN模型对象
    BpmnModel model = new BpmnModel();
    // 创建一个流程定义
    org.activiti.bpmn.model.Process process = new org.activiti.bpmn.model.Process();
    model.addProcess(process);
    process.setId("myProcess");
    process.setName("My Process");
    // 开始事件
    StartEvent startEvent = new StartEvent();
    startEvent.setId("startEvent");
    process.addFlowElement(startEvent);
    // 用户任务
    UserTask userTask = new UserTask();
    userTask.setName("User Task");
    userTask.setId("userTask");
    process.addFlowElement(userTask);
    // 结束事件
    EndEvent endEvent = new EndEvent();
    endEvent.setId("endEvent");
    process.addFlowElement(endEvent);
    // 添加流程顺序
    process.addFlowElement(new SequenceFlow("startEvent", "userTask"));
    process.addFlowElement(new SequenceFlow("userTask", "endEvent"));
    return model;
}

关闭流程部署验证

1
2
3
4

DeploymentBuilder builder = rs.createDeployment();
builder.addClasspathResource("error/schema_error.bpmn");
builder.disableSchemaValidation();  //关闭
builder.deploy();

查询文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 存储服务
RepositoryService rs = engine.getRepositoryService();

DeploymentBuilder builder = rs.createDeployment();
builder.addClasspathResource("my_text.txt");
Deployment dep = builder.deploy();
// 数据查询
InputStream is = rs.getResourceAsStream(dep.getId(), "my_text.txt");
int count = is.available();
byte[] contents = new byte[count];
is.read(contents);
String result = new String(contents);
//输入结果
System.out.println(result);

查询流程文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到流程存储服务对象
RepositoryService repositoryService = engine.getRepositoryService();
// 部署一份流程文件
Deployment dep = repositoryService.createDeployment()
        .addClasspathResource("gen.bpmn").deploy();
// 查询流程定义
//查询流程定义实体
ProcessDefinition def = repositoryService.createProcessDefinitionQuery()
        .deploymentId(dep.getId()).singleResult();
// 查询资源文件
InputStream is = repositoryService.getProcessModel(def.getId());
// 读取输入流
int count = is.available();
byte[] contents = new byte[count];
is.read(contents);
String result = new String(contents);
//输入输出结果
System.out.println(result);

查询流程图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到流程存储服务对象
RepositoryService repositoryService = engine.getRepositoryService();
// 部署一份流程文件与相应的流程图文件
Deployment dep = repositoryService.createDeployment()
        .addClasspathResource("gen.bpmn").deploy();
// 查询流程定义
ProcessDefinition def = repositoryService.createProcessDefinitionQuery()
        .deploymentId(dep.getId()).singleResult();
// 查询资源文件
InputStream is = repositoryService.getProcessDiagram(def.getId());
// 将输入流转换为图片对象  
BufferedImage image = ImageIO.read(is);
// 保存为图片文件
File file = new File("resource/result.png");
if (!file.exists()) file.createNewFile();
FileOutputStream fos = new FileOutputStream(file);
ImageIO.write(image, "png", fos);
fos.close();
is.close();

删除流程部署

1
2

repositoryService.deleteDeployment(dep.getId());
repositoryService.deleteDeployment(dep.getId(), true);  //级联删除（会删除运行实例和历史数据）

3、流程定义

自己指定流程图片

1
2
3
4
5
6
7

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 存储服务
RepositoryService rs = engine.getRepositoryService();

DeploymentBuilder builder = rs.createDeployment();
builder.addClasspathResource("test2.bpmn").addClasspathResource("test2.png");
builder.deploy();

流程中止
流程被中止后是不能被重新启动的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 存储服务
RepositoryService rs = engine.getRepositoryService();

DeploymentBuilder builder = rs.createDeployment();
builder.addClasspathResource("test3.bpmn");
Deployment dep = builder.deploy();

ProcessDefinition def = rs.createProcessDefinitionQuery()
        .deploymentId(dep.getId()).singleResult();  

System.out.println("id: " + def.getId());
rs.suspendProcessDefinitionByKey(def.getKey());
// 将会抛出异常，因为流程定义被中止了
RuntimeService runService = engine.getRuntimeService();
runService.startProcessInstanceByKey(def.getKey());

启动流程任务权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 存储服务
RepositoryService rs = engine.getRepositoryService();
IdentityService is = engine.getIdentityService();
TaskService ts = engine.getTaskService();
User user = is.newUser(UUID.randomUUID().toString());
user.setFirstName("Angus");
is.saveUser(user);
DeploymentBuilder builder = rs.createDeployment();
builder.addClasspathResource("test3.bpmn");
Deployment dep = builder.deploy();
ProcessDefinition def = rs.createProcessDefinitionQuery()
        .deploymentId(dep.getId()).singleResult();
rs.addCandidateStarterUser(def.getId(), user.getId());
//查询该用户有多少个流程可以启动
List<ProcessDefinition> defs = rs.createProcessDefinitionQuery().startableByUser(user.getId()).list();
for(ProcessDefinition de : defs) {
    System.out.println(de.getId());
}

###4、流程任务
任务候选人（组）
多少个用户或组能看见这个任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
TaskService ts = engine.getTaskService();
IdentityService is = engine.getIdentityService();
// 创建任务
String taskId = UUID.randomUUID().toString();
Task task = ts.newTask(taskId);
task.setName("test");
ts.saveTask(task);
//  创建用户
String userId = UUID.randomUUID().toString();
User user = is.newUser(userId);
user.setFirstName("angus");
is.saveUser(user);
// 设置任务的候选用户组
ts.addCandidateUser(taskId, userId);

/*添加用户到组*/
//is.createMembership(userId, groupId);

List<Task> tasks = ts.createTaskQuery().taskCandidateUser(userId).list();
System.out.println(userId + " 这个用户有权限处理的任务有：");
for(Task t : tasks) {
    System.out.println(t.getName());
}

任务持有人
当前处理该任务用户，一个任务只有一个持有人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
TaskService ts = engine.getTaskService();
IdentityService is = engine.getIdentityService();
// 创建任务
String taskId = UUID.randomUUID().toString();
Task task = ts.newTask(taskId);
task.setName("test1");
ts.saveTask(task);
//  创建用户
String userId = UUID.randomUUID().toString();
User user = is.newUser(userId);
user.setFirstName("angus1");
is.saveUser(user);
// 设置任务持有人
ts.setOwner(taskId, userId);
// ts.setOwner(taskId, "e110a0a5-1314-4c0c-9ba9-142447b11dea");
// 根据用户来查询他所持有的任务
List<Task> tasks = ts.createTaskQuery().taskOwner(userId).list();
for(Task t : tasks) {
    System.out.println(t.getName());
}
engine.close();

任务代理人

1
2
3
4
5

//任务被认领之后，其他人认领就会报错
ts.claim(taskId, user.getId());

//任务指定代理人
ts.setAssignee(taskId, user.getId());

任务完成
taskService.complete(task.getId());

4、参数与附件

设置参数

• a、流程配置文件设置

  1 2 3 4 5 6 7

  <!-- process标签里面 --> <dataObject id="personName" name="personName" itemSubjectRef="xsd:string"> <extensionElements> <activiti:value>Crazyit</activiti:value> </extensionElements> </dataObject>

• b、启动流程设置

  1 2 3 4 5 6 7

  Map<String,Object> map = new HashMap<>(); Person p = new Person(); p.setId(1); p.setName("angus"); map.put("p", p); map.put("key", "val1"); ProcessInstance pi = runService.startProcessInstanceById(pd.getId(),map);

• c、服务设置

  1 2	runService.setVariable(execution.getId(), "key",value); taskService.setVariable(task.getId(), "key", value);

• d、设置本地参数
  setVariable变成setVariableLocal

获取参数值

1
2

runService.getVariable(execution.getId(), "key");
taskService.getVariable(task.getId(), "key");

附件

5、启动流程

1
2
3
4
5
6
7

//通过ID启动并设置business_key参数
runService.startProcessInstanceById(pd.getId(), "test");
//通过key值启动
runService.startProcessInstanceByKey(pd.getKey());
//通过消息启动，消息开始事件
runService.startProcessInstanceByMessage(message);
//

6、流程操作与数据查询

task流程
taskService.complete(task.getId());
Receive Task流程
该task不会产生task数据，只有execution

1
2
3
4
5
6
7
8
9

// 启动流程
ProcessInstance pi = runService.startProcessInstanceById(pd.getId());
// 查当前的子执行流（只有一个）
Execution exe = runService.createExecutionQuery()
        .processInstanceId(pi.getId()).onlyChildExecutions()
        .singleResult();
System.out.println(pi.getId() + ", 当前节点：" + exe.getActivityId());
// 让它往前走
runService.trigger(exe.getId());

7、JOB

手动执行任务（act_run_job）

1
2
3
4

Job job = managementService.createJobQuery().singleResult();
//设置重试次数
managementService.setJobRetries(job.getId(), 1);
managementService.executeJob(job.getId());

六、其他

6.0版本支持activiti:candidateGroups=”${prd_add}”
5.X版本只能activiti:candidateGroups=”#{prd_add}”

例子

• ng-app 指令告诉 AngularJS，
  元素是 AngularJS 应用程序 的”所有者”。
• ng-model 指令把输入域的值绑定到应用程序变量 name。
• ng-bind 指令把应用程序变量 name 绑定到某个段落的 innerHTML。

1
2
3
4
5
6
7
8
9

<div ng-app="">
     <p>名字 : <input type="text" ng-model="name"></p>
     <h1>Hello {{name}}</h1>
</div>


<div ng-app="" ng-init="firstName='John'">
    <p>姓名为 <span ng-bind="firstName"></span></p>
</div>

ng-app作用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<div ng-app="myApp" ng-controller="myCtrl">
 
名: <input type="text" ng-model="firstName"><br>
姓: <input type="text" ng-model="lastName"><br>
<br>
姓名: {{firstName + " " + lastName}}
 
</div>
 
<script>
var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope) {
    $scope.firstName= "John";
    $scope.lastName= "Doe";
});
</script>

AngularJS 对象

1
2
3
4
5

<div ng-app="" ng-init="person={firstName:'John',lastName:'Doe'}">
 
<p>姓为 {{ person.lastName }}</p>
 
</div>

AngularJS 数组

1
2
3
4
5

<div ng-app="" ng-init="points=[1,15,19,2,40]">
 
<p>第三个值为 <span ng-bind="points[2]"></span></p>
 
</div>

重复 HTML 元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<div ng-app="" ng-init="names=['Jani','Hege','Kai']">
  <p>使用 ng-repeat 来循环数组</p>
  <ul>
    <li ng-repeat="x in names">
      {{ x }}
    </li>
  </ul>
</div>

<div ng-app="" ng-init="names=[
{name:'Jani',country:'Norway'},
{name:'Hege',country:'Sweden'},
{name:'Kai',country:'Denmark'}]">
 
<p>循环对象：</p>
<ul>
  <li ng-repeat="x    in names">
    {{ x.name + ', ' + x.country }}
  </li>
</ul>
 
</div>

创建自定义的指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<body ng-app="myApp">

<runoob-directive></runoob-directive>

<script>
var app = angular.module("myApp", []);
app.directive("runoobDirective", function() {
    return {
        restrict : "A",
        template : "<h1>自定义指令!</h1>"
    };
});
</script>

</body>

你可以通过以下方式来调用指令：

• 元素名
  <runoob-directive></runoob-directive>
• 属性
  <div runoob-directive></div>
• 类名
• 注释

restrict 值可以是以下几种:

• E 作为元素名使用
• A 作为属性使用
• C 作为类名使用
• M 作为注释使用
  restrict 默认值为 EA, 即可以通过元素名和属性名来调用指令。

ng-model 指令

1
2
3
4
5
6
7
8
9
10
11

<div ng-app="myApp" ng-controller="myCtrl">
    名字: <input ng-model="name">
    <h1>你输入了: {{name}}</h1>
</div>

<script>
var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope) {
    $scope.name = "John Doe";
});
</script>

验证用户输入

1
2
3
4
5

<form ng-app="" name="myForm">
    Email:
    <input type="email" name="myAddress" ng-model="text">
    <span ng-show="myForm.myAddress.$error.email">不是一个合法的邮箱地址</span>
</form>

应用状态

1
2
3
4
5
6
7
8
9

<form ng-app="" name="myForm" ng-init="myText = 'test@runoob.co">

Email:
<input type="email" name="myAddress" ng-model="myText" required>
<p>编辑邮箱地址，查看状态的改变。</p>
<h1>状态</h1>
<p>Valid: {{myForm.myAddress.$valid}} (如果输入的值是合法的则为 true)。</p>
<p>Dirty: {{myForm.myAddress.$dirty}} (如果值改变则为 true)。</p>
<p>Touched: {{myForm.myAddress.$touched}} (如果通过触屏点击则为 true)。</p>

CSS 类

1
2
3
4
5
6
7
8
9
10
11

<style>
input.ng-invalid {
    background-color: lightblue;
}
</style>
<body>

<form ng-app="" name="myForm">
    输入你的名字:
    <input name="myAddress" ng-model="text" required>
</form>

ng-model 指令根据表单域的状态添加/移除以下类：

• ng-valid: 验证通过
• ng-invalid: 验证失败
• ng-valid-[key]: 由$setValidity添加的所有验证通过的值
• ng-invalid-[key]: 由$setValidity添加的所有验证失败的值
• ng-pristine: 控件为初始状态
• ng-dirty: 控件输入值已变更
• ng-touched: 控件已失去焦点
• ng-untouched: 控件未失去焦点
• ng-pending: 任何为满足$asyncValidators的情况

AngularJS Scope(作用域)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<div ng-app="myApp" ng-controller="myCtrl">
    <input ng-model="name">
    <h1>{{greeting}}</h1>
    <button ng-click='sayHello()'>点我</button>    
</div>
 
<script>
var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope) {
    $scope.name = "Runoob";
    $scope.sayHello = function() {
        $scope.greeting = 'Hello ' + $scope.name + '!';
    };
});
</script>

根作用域

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<div ng-app="myApp" ng-controller="myCtrl">

<h1>{{lastname}} 家族成员:</h1>

<ul>
    <li ng-repeat="x in names">{{x}} {{lastname}}</li>
</ul>

</div>

<script>
var app = angular.module('myApp', []);

app.controller('myCtrl', function($scope, $rootScope) {
    $scope.names = ["Emil", "Tobias", "Linus"];
    $rootScope.lastname = "Refsnes";
});
</script>

外部文件中的控制器

1
2
3
4
5
6
7
8
9
10

<div ng-app="myApp" ng-controller="personCtrl">

First Name: <input type="text" ng-model="firstName"><br>
Last Name: <input type="text" ng-model="lastName"><br>
<br>
Full Name: {{firstName + " " + lastName}}

</div>

<script src="personController.js"></script>

AngularJS 过滤器

currency 格式化数字为货币格式。
filter 从数组项中选择一个子集。
lowercase 格式化字符串为小写。
orderBy 根据某个表达式排列数组。
uppercase 格式化字符串为大写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<div ng-app="myApp" ng-controller="personCtrl">
<input type="number" ng-model="quantity">
<input type="number" ng-model="price">
<p>姓名为 {{ lastName | uppercase }}</p>
<p>姓名为 {{ lastName | lowercase }}</p>
<p>总价 = {{ (quantity * price) | currency }}</p>
</div>

<!--排序-->
<li ng-repeat="x in names | orderBy:'country'">
    {{ x.name + ', ' + x.country }}
</li>

<!--过滤输入-->
<p><input type="text" ng-model="test"></p>

<ul>
  <li ng-repeat="x in names | filter:test | orderBy:'country'">
    {{ (x.name | uppercase) + ', ' + x.country }}
  </li>
</ul>

自定义过滤器

1
2
3
4
5
6
7
8
9

var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope) {
    $scope.msg = "Runoob";
});
app.filter('reverse', function() { //可以注入依赖
    return function(text) {
        return text.split("").reverse().join("");
    }
});

AngularJS 服务

$location服务

返回当前页面的 URL 地址。

1 2 3 4

var app = angular.module('myApp', []); app.controller('myCtrl', function($scope, $location) { $scope.myUrl = $location.absUrl(); });

$http 服务

向服务器发送Http请求

1 2 3 4 5 6

var app = angular.module('myApp', []); app.controller('myCtrl', function($scope, $http) { $http.get("welcome.htm").then(function (response) { $scope.myWelcome = response.data; }); });

$timeout 服务

$timeout 服务对应了 JS window.setTimeout 函数。

1 2 3 4 5 6 7

var app = angular.module('myApp', []); app.controller('myCtrl', function($scope, $timeout) { $scope.myHeader = "Hello World!"; $timeout(function () { $scope.myHeader = "How are you today?"; }, 2000); });

$interval 服务

$interval 服务对应了 JS window.setInterval 函数。

1 2 3 4 5 6

app.controller('myCtrl', function($scope, $interval) { $scope.theTime = new Date().toLocaleTimeString(); $interval(function () { $scope.theTime = new Date().toLocaleTimeString(); }, 1000); });

创建自定义服务

1
2
3
4
5
6
7
8
9
10

var app = angular.module('myApp', []);

app.service('hexafy', function() {
	this.myFunc = function (x) {
        return x.toString(16);
    }
});
app.controller('myCtrl', function($scope, hexafy) {
  $scope.hex = hexafy.myFunc(255);
});

过滤器中，使用自定义服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<div ng-app="myApp">
    在过滤器中使用服务:
    <h1>{{255 | myFormat}}</h1>
</div>
<script>
var app = angular.module('myApp', []);
app.service('hexafy', function() {
	this.myFunc = function (x) {
        return x.toString(16);
    }
});
app.filter('myFormat',['hexafy', function(hexafy) {
    return function(x) {
        return hexafy.myFunc(x);
    };
}]);
</script>

$http

1
2
3
4
5
6
7
8
9
10
11
12
13

// 简单的 GET 请求，可以改为 POST
$http({
    method: 'GET',
    url: '/someUrl'
}).then(function successCallback(response) {
        // 请求成功执行代码
    }, function errorCallback(response) {
        // 请求失败执行代码
});

//简写
$http.get('/someUrl', config).then(successCallback, errorCallback);
$http.post('/someUrl', data, config).then(successCallback, errorCallback);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<div ng-app="myApp" ng-controller="siteCtrl"> 
 
<ul>
  <li ng-repeat="x in names">
    {{ x.Name + ', ' + x.Country }}
  </li>
</ul>
 
</div>
 
<script>
var app = angular.module('myApp', []);
app.controller('siteCtrl', function($scope, $http) {
  $http.get("http://www.runoob.com/try/angularjs/data/sites.php")
  .then(function (response) {$scope.names = response.data.sites;});
});
</script>

AngularJS Select(选择框)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<div ng-app="myApp" ng-controller="myCtrl">
 
<select ng-init="selectedName = names[0]" ng-model="selectedName" ng-options="x for x in names">
</select>
 <!--也可以使用下面的-->
 <select>
<option ng-repeat="x in names">{{x}}</option>
</select>
 
</div>
 
<script>
var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope) {
    $scope.names = ["Google", "Runoob", "Taobao"];
});
</script>

ng-options 与 ng-repeat区别

http://www.runoob.com/angularjs/angularjs-select.html

AngularJS 表格

http://www.runoob.com/angularjs/angularjs-tables.html

AngularJS HTML DOM和事件

ng-disabled 指令

1
2
3
4
5
6
7
8
9
10
11

<div ng-app="" ng-init="mySwitch=false">
<p>
<button ng-disabled="mySwitch">点我!</button>
</p>
<p>
<input type="checkbox" ng-model="mySwitch"/>按钮
</p>
<p>
{{ mySwitch }}
</p>
</div>

ng-show 指令

1
2
3
4

<div ng-app="" ng-init="hour=13">
<p ng-show="true">我是可见的。</p>
<p ng-show="false">我是不可见的。</p>
<p ng-show="hour > 12">我是可见的。</p>

ng-hide 指令

1
2

<p ng-hide="true">我是不可见的。</p>
<p ng-hide="false">我是可见的。</p>

ng-click 指令

1
2

<button ng-click="count = count + 1">点我！</button>
<p>{{ count }}</p>

隐藏 HTML 元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<div ng-app="myApp" ng-controller="personCtrl">

<button ng-click="toggle()">隐藏/显示</button>

<p ng-hide="myVar">
<!--<p ng-show="myVar">-->
名: <input type="text" ng-model="firstName"><br>
姓名: <input type="text" ng-model="lastName"><br>
<br>
Full Name: {{firstName + " " + lastName}}
</p>

</div>

<script>
var app = angular.module('myApp', []);
app.controller('personCtrl', function($scope) {
    $scope.firstName = "John",
    $scope.lastName = "Doe"
    $scope.myVar = false;
    $scope.toggle = function() {
        $scope.myVar = !$scope.myVar;
    };
});
</script>

AngularJS 表单

http://www.runoob.com/angularjs/angularjs-forms.html

数据绑定

<input type="text" ng-model="firstname">

Checkbox（复选框）

单选框

单选框使用同一个 ng-model

下拉菜单

HTML 表单

AngularJS 全局 API

全局 API 函数使用 angular 对象进行访问。

• angular.lowercase() 转换字符串为小写
• angular.uppercase() 转换字符串为大写
• angular.isString() 判断给定的对象是否为字符串，如果是返回 true。
• angular.isNumber() 判断给定的对象是否为数字，如果是返回 true。

switch case语句

1
2
3
4
5
6

<p ng-switch = "x3">
  是不是字符串：
  <label ng-switch-when = "true">是</label>
  <label ng-switch-when = "false">不是</label>
  <label ng-switch-when = ""></label>
</p>

AngularJS 包含

包含html页面

ng-include="'runoob.htm'"

跨域包含

AngularJS 动画

AngularJS 依赖注入

AngularJS 路由

###

ng-bind 和花括号的区别就是 启动加载的时候显示不同

同步阻塞IO—-BIO
同步非阻塞IO—-JAVA-NIO
异步非阻塞IO—-JAVA-AIO

Channel：通道
Buffer：缓冲区
Selector：选择器

多个通道注册到一个选择器中，所有的数据都是与缓冲区交互，然后缓冲区与通道交互

1. 变量声明const和let

• let表示变量（局部变量）
• const表示常量（JAVA的final）

2. 模板字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

const name = 'lux';
console.log(`hello ${name}`) //hello lux

//多行文本--使用反引号
// ES5
var msg = "Hi \
man!
"
// ES6
const template = `<div>
    <span>hello world</span>
</div>`

// 1.includes：判断是否包含然后直接返回布尔值
const str = 'hahay'
console.log(str.includes('y')) // true

// 2.repeat: 获取字符串重复n次
const str = 'he'
console.log(str.repeat(3)) // 'hehehe'
//如果你带入小数, Math.floor(num) 来处理
// s.repeat(3.1) 或者 s.repeat(3.9) 都当做成 s.repeat(3) 来处理

// 3. startsWith 和 endsWith 判断是否以 给定文本 开始或者结束
const str =  'hello world!'
console.log(str.startsWith('hello')) // true
console.log(str.endsWith('!')) // true

3. 函数

默认参数，类似于python

1
2
3

function action(num = 200) {
    console.log(num)
}

箭头函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

x => x * x
//等于下面
function (x) {
    return x * x;
}

x => {
    if (x > 0) {
        return x * x;
    }
    else {p 
        return - x * x;
    }
}

// 两个参数:
(x, y) => x * x + y * y

// 无参数:
() => 3.14

// 可变参数:
(x, y, ...rest) => {
    var i, sum = x + y;
    for (i=0; i<rest.length; i++) {
        sum += rest[i];
    }
    return sum;
}

//返回对象
x => ({ foo: x })

4. 拓展的对象功能

对象初始化简写

1
2
3
4
5
6

function people(name, age) {
    return {
        name,       // name : name
        age         // age : age
    };
}

浅克隆

5. 更方便的数据访问–解构

1
2
3
4
5
6
7
8
9
10
11
12

//对象
const people = {
    name: 'lux',
    age: 20
}
const { name, age } = people
console.log(`${name} --- ${age}`)
//数组
const color = ['red', 'blue']
const [first, second] = color
console.log(first) //'red'
console.log(second) //'blue'

Object.assign() 可以把任意多个源对象自身可枚举的属性拷贝给目标对象，然后返回目标对象。第一参数即为目标对象。在实际项目中，我们为了不改变源对象。一般会把目标对象传为{}

6. Spread Operator 展开运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//数组
const color = ['red', 'yellow']
const colorful = [...color, 'green', 'pink']
console.log(colorful) //[red, yellow, green, pink]

//对象
const alp = { fist: 'a', second: 'b'}
const alphabets = { ...alp, third: 'c' }
console.log(alphabets) //{ "fist": "a", "second": "b", "third": "c"

//数组
const number = [1,2,3,4,5]
const [first, ...rest] = number
console.log(rest) //2,3,4,5
}

7. import导入模块、export导出模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//全部导入
import people from './example'

//有一种特殊情况，即允许你将整个模块当作单一对象进行导入
//该模块的所有导出都会作为对象的属性存在
import * as example from "./example.js"
console.log(example.name)
console.log(example.age)
console.log(example.getName())

//导入部分
import {name, age} from './example'

// 导出默认, 有且只有一个默认
export default App

// 部分导出
export class App extend Component {};

作者：陈嘻嘻啊
链接：https://www.jianshu.com/p/287e0bb867ae
來源：简书

python把函数作为参数

1
2
3
4

def add(x, y, f):
    return f(x) + f(y)
add(-5, 9, abs)
# 其实是调用 abs(-5) + abs(9)

常用函数

1. map()函数

   1 2 3 4

   def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) # 输出 [1, 4, 9, 10, 25, 36, 49, 64, 81]

2. reduce()函数

   1 2 3

   def f(x, y): return x + y print reduce(f, [1, 3, 5, 7, 9])

3. filter()函数

   1 2 3 4

   def is_odd(x): return x % 2 == 1 filter(is_odd, [1, 4, 6, 7, 9, 12, 17]) # 输出 [1, 7, 9, 17]

4. sorted()函数

   1 2 3 4 5 6 7 8 9 10

   sorted([36, 5, 12, 9, 21]) # 排序 def reversed_cmp(x, y): if x > y: return -1 if x < y: return 1 return 0 sorted([36, 5, 12, 9, 21], reversed_cmp) # 输出 [36, 21, 12, 9, 5]

5. 装饰者模式

   1 2 3 4 5 6 7 8 9 10 11

   from functools import reduce def log(f): def fn(x): print('call ' + f.__name__ + '()...') return f(x) return fn @log # 指定被装饰的方法 def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1)) print(factorial(10))

6. 偏函数

   1 2 3

   import functools int2 = functools.partial(int, base=2) # int2就是一个偏函数

服务注册 spring Cloud eureka

他是一个服务注册中心，服务消费者会注册到服务中心，服务实例会通过心跳方式定时通知服务中心（定时向注册中心更新实例。默认30S），Eureka Server收到心跳后，会通知集群里的其它Eureka Server更新此实例的状态。

• 在Service Provider服务shutdown的时候，主动通知Eureka Server把自己剔除，从而避免客户端调用已经下线的服务。

• Eureka Server会定时，进行检查，如果发现实例在在一定时间，内没有收到心跳，则会注销此实例。（间隔值是eureka.server.eviction-interval-timer-in-ms，默认值为60）

• 保护模式：则会触发自我保护模式，此时Eureka Server此时会认为这是网络问题，它不会注销任何过期的实例。

其他服务注册中心也有Consul和Zookeeper

依赖

1
2
3
4
5
6
7
8
9
10

<!-- eureka server -->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>
<!-- eureka client -->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

配置文件

server

1
2
3
4
5
6
7
8
9
10
11
12
13

server.port=9990
#服务名称
spring.application.name=eureka-server
#服务地址
eureka.instance.hostname=127.0.0.1
#是否注册eureka（当高可用模式下才会启用）  是否向服务注册中心注册自己
eureka.client.register-with-eureka=false
#是否启用获取服务注册信息
eureka.client.fetch-registry=false
#注册和查询都需依赖该地址，多个以逗号分隔
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/
#留存的服务实例低于多少比列进入保护模式  默认是85%
eureka.server.renewal-percent-threshold=0.5

client

1
2
3
4
5
6
7
8

server.port=8083
spring.application.name=comment
#eureka server地址
eureka.client.serviceUrl.defaultZone=http://127.0.0.1:9990/eureka/
# 心跳间隔 5s 默认30s
eureka.instance.lease-renewal-interval-in-seconds=5
# 服务失效时间： 如果多久没有收到请求，则可以删除服务 默认90s
eureka.instance.lease-expiration-duration-in-seconds=10

代码

eureka server在启动类添加注解@EnableEurekaServer
eureka client在启动类添加注解@EnableEurekaClient

@EnableEurekaClient和@EnableEurekaClient功能类似，但是@EnableEurekaClient只用于eureka。

网关服务 apigateway

我这里的例子是web服务，所有采用的是springBoot作为网关。如果是应用服务可以用spring Cloud zuul

所有的接口都是通过网关提供出去的，所以身份认证、路由服务、流量控制、日志统计代码编写都是在网关服务。

springBoot

配置

1
2
3
4
5
6

server.port=8090
spring.application.name=api-gateway
###########eureka配置#################
eureka.client.serviceUrl.defaultZone=http://127.0.0.1:9990/eureka/
#是否向服务注册中心注册自己
#eureka.client.register-with-eureka=false

spring Cloud zuul

zuul主要就是路由转发和过滤器

依赖

1
2
3
4

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

配置

1
2
3
4
5
6
7
8

server.port=8769
spring.application.name=service-zuul
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka
zuul.routes.api-a.path=/api-a/**
zuul.routes.api-a.path.serviceId=service-a
zuul.routes.api-b.path=/api-b/**
zuul.routes.api-b.path.serviceId=service-b
#api-a 和api-b 都是对应子服务的名称

启动

启动类添加@EnableZuulProxy注解

网关与子服务通信

两种通信方式：restTemplate+httpclient和feign

restTemplate+httpclient

1、注入restTemplate

1
2
3
4
5

@Bean
//@LoadBalanced
RestTemplate restTemplate() {
	return new RestTemplate();
}

2、调用原子服务

post

1

int result = restTemplate.postForObject("http://comment/insert", comment, Integer.class);

get

1
2
3

Map<String, Integer> map = new HashMap<>();
map.put("nid", nid);
List<CommentUser> response = restTemplate.getForObject("http://comment/list?nid={nid}", List.class,map);

其中comment就是服务配置文件中的spring.application.name=comment

feign

依赖

1 2 3 4

<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-feign</artifactId> </dependency>

请求方式

类似于controller编写

1
2
3
4
5
6
7
8
9

@FeignClient(value = "comment")
public interface NewsFeign {

	@RequestMapping(value="insert",method=RequestMethod.POST)
	public int insert(@RequestBody Comment comment);
	
	@RequestMapping(value="list",method=RequestMethod.GET)
	public List<CommentUser> queryAll(int nid);
}

负载均衡ribbon

restTemplate+httpclient方式

1、需要添加依赖

1
2
3
4

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-ribbon</artifactId>
</dependency>

2、添加注解@LoadBalanced

1
2
3
4
5

@Bean
@LoadBalanced		// 启动负载均衡
public RestTemplate restTemplate(){
	return new RestTemplate();
}

feign

feign默认集成了ribbon

断路器hystrix

服务隔离（每个服务有单独线程池）、熔断(也可以称为断路)、降级等手段控制依赖服务的延迟与失败。
防止单个服务的故障，从而影响整个系统的性能，避免分布式环境里大量级联失败。使用快速失败策略，当调用一个服务超时，或者，线程池满了的情况，会立即拒绝服务而不会排队等待，还有服务降级，当调用失败的时候，就调用备用的服务。

依赖

1
2
3
4
5
6
7
8

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置

1
2
3
4
5
6
7
8
9
10
11
12
13

###########hystrix配置################
#执行超时时间，超过这个时间执行没反应就返回
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=2000
#并发执行的最大线程数，默认10
hystrix.threadpool.default.coreSize=5
#线程最大队列数 默认1
hystrix.threadpool.default.maxQueueSize=1
#最大的线程池
#hystrix.threadpool.default.maximumSize=10
#错误比率阀值，如果错误率>=该值，断路器会被打开，并短路所有请求触发fallback。默认50
hystrix.command.default.circuitBreaker.errorThresholdPercentage=1
#触发短路的时间值，当该值设为5000时，则当触发circuit break后的5000毫秒内都会拒绝request，也就是5000毫秒后才会关闭circuit。默认5000
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=100000

代码

可以使用注解自定义配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37