Created by Jerry Wang, last modified on Jul 16, 2014下列report能给指定的product创建3个用户输入的distribution chain：执行完report后UI检查结果如下:detail page:source code如下:REPORT prod_create_distr_chain.PARAMETERS: id TYPE comm_product-product_id OBLIGATORY DEFAULT 'R15'.SELECTION-SCREEN BEGIN OF BLOCK b1  WITH FRAME TITLE txt1.  PARAMETERS: sa_org1 type string OBLIGATORY DEFAULT 'O 50001213',            dc1 type string OBLIGATORY DEFAULT '01',            shotxt1 type string OBLIGATORY DEFAULT 'Inbox Test',            satxt1 type string OBLIGATORY DEFAULT 'IC Inbox Test',            dctxt1 type string OBLIGATORY DEFAULT 'Distribution channel 01',            dcid1 type string OBLIGATORY DEFAULT 'O 50001213 / 01',            long1 type string OBLIGATORY DEFAULT 'Sales Organization Inbox Test , Distrib.Channel 01'.SELECTION-SCREEN END OF BLOCK b1.SELECTION-SCREEN BEGIN OF BLOCK b2  WITH FRAME TITLE txt2.  PARAMETERS: sa_org2 type string OBLIGATORY DEFAULT 'O 50001194',            dc2 type string OBLIGATORY DEFAULT '02',            shotxt2 type string OBLIGATORY DEFAULT 'Labs',            satxt2 type string OBLIGATORY DEFAULT 'SAP Labs SH',            dctxt2 type string OBLIGATORY DEFAULT 'for test',            dcid2 type string OBLIGATORY DEFAULT 'O 50001194 / 02',            long2 type string OBLIGATORY DEFAULT 'Sales Organization Labs , Distrib.Channel 02'.SELECTION-SCREEN END OF BLOCK b2.SELECTION-SCREEN BEGIN OF BLOCK b3  WITH FRAME TITLE txt3.  PARAMETERS: sa_org3 type string OBLIGATORY DEFAULT 'O 50004509',            dc3 type string OBLIGATORY DEFAULT '30',            shotxt3 type string OBLIGATORY DEFAULT 'Crm-sales',            satxt3 type string OBLIGATORY DEFAULT 'Crm-sales',            dctxt3 type string OBLIGATORY DEFAULT '',            dcid3 type string OBLIGATORY DEFAULT 'O 50004509 / 30',            long3 type string OBLIGATORY DEFAULT 'Sales Organization Crm-sales , Distrib.Channel 30'.SELECTION-SCREEN END OF BLOCK b3.INITIALIZATION.    txt1 = 'Distribution chain1'.    txt2 = 'Distribution chain2'.    txt3 = 'Distribution chain3'.START-OF-SELECTION.DATA(product) = cl_crm_prod_internal_tool=>get_prod_by_id( id ).DATA: lv_index TYPE int4 VALUE 1.DATA(lo_dist_chain) = product->get_related_entities( iv_relation_name = 'ProductDistrChain' ).IF lo_dist_chain->size( ) > 0.  WRITE: / 'Current product already has distribution chain maintained.' COLOR COL_NEGATIVE.  RETURN.ENDIF.* 1DATA(lo_chain_single) = product->create_related_entity( iv_relation_name = 'ProductDistrChain' iv_child_name = 'ProdDistrChain' ).lo_chain_single->set_property_as_string( iv_attr_name = 'SALES_ORG' iv_value = sa_org1 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DISTR_CHAN' iv_value = dc1 ).lo_chain_single->set_property_as_string( iv_attr_name = 'SHORT_DESC' iv_value = shotxt1 ).lo_chain_single->set_property_as_string( iv_attr_name = 'SALES_DESC' iv_value = satxt1 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DISTR_DESC' iv_value = dctxt1 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DSTRBCHAIN_ID' iv_value = dcid1 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DESCRIPTION' iv_value = long1 ).*2lo_chain_single = product->create_related_entity( iv_relation_name = 'ProductDistrChain' iv_child_name = 'ProdDistrChain' ).lo_chain_single->set_property_as_string( iv_attr_name = 'SALES_ORG' iv_value = sa_org2 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DISTR_CHAN' iv_value = dc2 ).lo_chain_single->set_property_as_string( iv_attr_name = 'SHORT_DESC' iv_value = shotxt2 ).lo_chain_single->set_property_as_string( iv_attr_name = 'SALES_DESC' iv_value = satxt2 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DISTR_DESC' iv_value = dctxt2 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DSTRBCHAIN_ID' iv_value = dcid2 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DESCRIPTION' iv_value = long2 ).lo_chain_single = product->create_related_entity( iv_relation_name = 'ProductDistrChain' iv_child_name = 'ProdDistrChain' ).lo_chain_single->set_property_as_string( iv_attr_name = 'SALES_ORG' iv_value = sa_org3 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DISTR_CHAN' iv_value = dc3 ).lo_chain_single->set_property_as_string( iv_attr_name = 'SHORT_DESC' iv_value = shotxt3 ).lo_chain_single->set_property_as_string( iv_attr_name = 'SALES_DESC' iv_value = satxt3 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DISTR_DESC' iv_value = dctxt3 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DSTRBCHAIN_ID' iv_value = dcid3 ).lo_chain_single->set_property_as_string( iv_attr_name = 'DESCRIPTION' iv_value = long3 ).DATA(lv_saved) = cl_crm_prod_internal_tool=>save_transaction( ).WRITE: / 'saved successfully?' , lv_saved COLOR COL_TOTAL.class CL_CRM_PROD_INTERNAL_TOOL definition  public  final  create public .public section.  class-methods CLASS_CONSTRUCTOR .  class-methods GET_PROD_BY_ID    importing      !IV_PRODUCT_ID type COMM_PRODUCT-PRODUCT_ID    returning      value(RO_BOL) type ref to CL_CRM_BOL_ENTITY .  class-methods SAVE_TRANSACTION    returning      value(RV_SUCCESS) type ABAP_BOOL .protected section.private section.  class-data SO_BOL_CORE type ref to CL_CRM_BOL_CORE .ENDCLASS.CLASS CL_CRM_PROD_INTERNAL_TOOL IMPLEMENTATION.* ---------------------------------------------------------------------------------------+* | Static Public Method CL_CRM_PROD_INTERNAL_TOOL=>CLASS_CONSTRUCTOR* +-------------------------------------------------------------------------------------------------+* +--------------------------------------------------------------------------------------  method CLASS_CONSTRUCTOR.    so_bol_core = cl_crm_bol_core=>get_instance( ).    so_bol_core->load_component_set( 'PROD_ALL' ).  endmethod.* ---------------------------------------------------------------------------------------+* | Static Public Method CL_CRM_PROD_INTERNAL_TOOL=>GET_PROD_BY_ID* +-------------------------------------------------------------------------------------------------+* | [--->] IV_PRODUCT_ID                  TYPE        COMM_PRODUCT-PRODUCT_ID* | [<-()] RO_BOL                         TYPE REF TO CL_CRM_BOL_ENTITY* +--------------------------------------------------------------------------------------  METHOD get_prod_by_id.    DATA:      lo_collection      TYPE REF TO if_bol_entity_col,      lo_root_entity     TYPE REF TO cl_crm_bol_entity,      lv_view_name       TYPE crmt_view_name,      lv_query_name      TYPE crmt_ext_obj_name,      lt_query_parameter TYPE crmt_name_value_pair_tab,      ls_query_parameter LIKE LINE OF lt_query_parameter,      lv_size            TYPE i.    ls_query_parameter-name = 'PRODUCT_ID'.    ls_query_parameter-value = iv_product_id.    APPEND ls_query_parameter TO lt_query_parameter.    ls_query_parameter-name = 'MAX_ROWS'.    ls_query_parameter-value = 1.    APPEND ls_query_parameter TO lt_query_parameter.    lv_query_name = 'ProdAdvancedSearchProducts'.    lo_collection = so_bol_core->query(        iv_query_name               = lv_query_name        it_query_params             = lt_query_parameter        iv_view_name                = lv_view_name ).    ASSERT lo_collection IS NOT INITIAL.    ASSERT lo_collection->size( ) = 1.    ro_bol = lo_collection->get_current( ).  ENDMETHOD.* ---------------------------------------------------------------------------------------+* | Static Public Method CL_CRM_PROD_INTERNAL_TOOL=>SAVE_TRANSACTION* +-------------------------------------------------------------------------------------------------+* | [<-()] RV_SUCCESS                     TYPE        ABAP_BOOL* +--------------------------------------------------------------------------------------  method SAVE_TRANSACTION.    so_bol_core->modify( ).    DATA(lo_transaction) = so_bol_core->get_transaction( ).    DATA(lv_changed) = lo_transaction->check_save_needed( ).    CHECK lv_changed EQ abap_true.    DATA(lv_success) = lo_transaction->save( ).    IF lv_success = abap_true.       lo_transaction->commit( ).       rv_success = abap_true.    ELSE.       lo_transaction->rollback( ).    ENDIF.  endmethod.ENDCLASS.

任务用户任务描述用户任务用来设置必须由人员完成的工作当流程执行到用户任务,会创建一个新任务,并把这个新任务加入到分配人或群组的任务列表中图形标记用户任务显示成一个普通任务(圆角矩形),左上角有一个小用户图标XML内容XML中的用户任务定义:id属性是必须的,name属性是可选的:<userTask id="theTask" name="Important task" />用户任务可以设置描述,添加documentation元素可以定义描述:<userTask id="theTask" name="Schedule meeting" > <documentation> Schedule an engineering meeting for next week with the new hire. </documentation>描述文本可以通过标准的java方法来获取:task.getDescription()持续时间任务可以用一个字段来描述任务的持续时间可以使用查询API来对持续时间进行搜索,根据在时间之前或之后进行搜索Activiti提供了一个节点扩展,在任务定义中设置一个表达式,这样在任务创建时就可以设置初始持续时间表达式应该是:java.util.Datejava.util.String(ISO8601格式),ISO8601持续时间(比如PT50M)null在流程中使用上述格式输入日期,或在前一个服务任务中计算一个时间.这里使用了持续时间,持续时间会基于当前时间进行计算,再通过给定的时间段累加: 使用"PT30M"作为持续时间,任务就会从现在开始持续30分钟<userTask id="theTask" name="Important task" activiti:dueDate="${dateVariable}"/>任务的持续时间也可以通过TaskService修改,或在TaskListener中通过传入的DelegateTask参数修改用户分配用户任务可以直接分配给一个用户,通过humanPerformer元素定义humanPerformer定义需要一个resourceAssignmentExpression来实际定义用户.目前只支持formalExpressions<process ... > ... <userTask id='theTask' name='important task' > <humanPerformer> <resourceAssignmentExpression> <formalExpression>kermit</formalExpression> </resourceAssignmentExpression> </humanPerformer> </userTask>只有一个用户可以作为任务的执行者分配用户在activiti中,用户叫做执行者拥有执行者的用户不会出现在其他人的任务列表中,只能出现执行者的个人任务列表中直接分配给用户的任务可以通过TaskService获取:List<Task> tasks = taskService.createTaskQuery().taskAssignee("kermit").list();任务也可以加入到人员的候选任务列表中.需要使用potentialOwner元素用法和humanPerformer元素类似,需要指定表达式中的每个项目是人员还是群组<process ... > ... <userTask id='theTask' name='important task' > <potentialOwner> <resourceAssignmentExpression> <formalExpression>user(kermit), group(management)</formalExpression> </resourceAssignmentExpression> </potentialOwner> </userTask>使用potentialOwner元素定义的任务可以通过TaskService获取:List<Task> tasks = taskService.createTaskQuery().taskCandidateUser("kermit");这会获取所有kermit为候选人的任务,表达式中包含user(kermit).这也会获得所有分配包含kermit这个成员的群组(比如,group(management),前提是kermit是这个组的成员,并且使用了activiti的账号组件).用户所在的群组是在运行阶段获取的, 它们可以通过IdentityService进行管理如果没有显式指定设置的是用户还是群组,引擎会默认当做群组处理下面的设置与使用group(accountancy)一样:<formalExpression>accountancy</formalExpression>Activiti对任务分配的扩展当分配不复杂时,用户和组的设置非常麻烦.为避免复杂性,可以使用用户任务的自定义扩展assignee属性: 直接把用户任务分配给指定用户(和使用humanPerformer 效果完全一样)<userTask id="theTask" name="my task" activiti:assignee="kermit" />candidateUsers属性: 为任务设置候选人(和使用potentialOwner效果完全一样,不需要像使用potentialOwner通过user(kermit)声明,这个属性只能用于人员)<userTask id="theTask" name="my task" activiti:candidateUsers="kermit, gonzo" />candidateGroups属性: 为任务设置候选组(和使用potentialOwner效果完全一样,不需要像使用potentialOwner通过group(management)声明,这个属性只能用于群组)<userTask id="theTask" name="my task" activiti:candidateGroups="management, accountancy" />candidateUsers和candidateGroups可以同时设置在同一个用户任务中Activiti中虽然有账号管理组件和IdentityService ,账号组件不会检测设置的用户是否存在. Activiti允许与其他已存的账户管理方案集成使用创建事件的任务监听器 来实现自定义的分配逻辑:<userTask id="task1" name="My task" > <extensionElements> <activiti:taskListener event="create" class="org.activiti.MyAssignmentHandler" /> </extensionElements> </userTask>DelegateTask会传递给TaskListener的实现,通过它可以设置执行人,候选人和候选组public class MyAssignmentHandler implements TaskListener { public void notify(DelegateTask delegateTask) { // Execute custom identity lookups here // and then for example call following methods: delegateTask.setAssignee("kermit"); delegateTask.addCandidateUser("fozzie"); delegateTask.addCandidateGroup("management"); ... } }使用spring时,使用表达式把任务监听器设置为spring代理的bean,让这个监听器监听任务的创建事件示例:执行者会通过调用ldapService这个spring bean的findManagerOfEmployee方法获得.流程变量emp会作为参数传递给bean<userTask id="task" name="My Task" activiti:assignee="${ldapService.findManagerForEmployee(emp)}"/>可以用来设置候选人和候选组:<userTask id="task" name="My Task" activiti:candidateUsers="${ldapService.findAllSales()}"/>方法返回类型只能为String(候选人) 或Collection < String >(候选组):public class FakeLdapService { public String findManagerForEmployee(String employee) { return "Kermit The Frog"; } public List<String> findAllSales() { return Arrays.asList("kermit", "gonzo", "fozzie"); } }脚本任务描述脚本任务是一个自动节点当流程到达脚本任务,会执行对应的脚本图形标记脚本任务显示为标准BPMN 2.0任务(圆角矩形),左上角有一个脚本小图标XML内容脚本任务定义需要指定script和scriptFormat<scriptTask id="theScriptTask" name="Execute script" scriptFormat="groovy"> <script> sum = 0 for ( i in inputArray ) { sum += i } </script> </scriptTask>scriptFormat的值必须兼容JSR-223(java平台的脚本语言).默认Javascript会包含在JDK中,不需要额外的依赖.如果要使用其他的脚本引擎,必须要是JSR-223引擎兼容的.还需要把对应的jar添加到classpath下, 并使用合适的名称:activiti单元测试经常使用groovygroovy脚本引擎放在groovy-all.jar中,在2.0版本之前,脚本引擎是groovy jar的一部分.使用需要添加依赖:<dependency> <groupId>org.codehaus.groovy</groupId> <artifactId>groovy-all</artifactId> <version>2.x.x<version> </dependency>脚本变量到达脚本任务的流程可以访问的所有流程变量,都可以在脚本中使用<script> sum = 0 for ( i in inputArray ) { sum += i } </script>也可以在脚本中设置流程变量,直接调用execution.setVariable("variableName", variableValue)默认,不会自动保存变量(activiti 5.12之前)可以在脚本中自动保存任何变量,只要把scriptTask的autoStoreVariables属性设置为true最佳实践是不要使用,而是显式调用execution.setVariable()<scriptTask id="script" scriptFormat="JavaScript" activiti:autoStoreVariables="false">参数默认为false: 如果没有为脚本任务定义设置参数,所有声明的变量将只存在于脚本执行的阶段在脚本中设置变量: 这些命名已经被占用,不能用作变量名- out, out:print, lang:import, context, elcontext.<script> def scriptVar = "test123" execution.setVariable("myVar", scriptVar) </script>脚本结果脚本任务的返回值可以通过制定流程变量的名称,分配给已存在或者一个新流程变量,需要使用脚本任务定义的'activiti:resultVariable'属性任何已存在的流程变量都会被脚本执行的结果覆盖如果没有指定返回的变量名,脚本的返回值会被忽略<scriptTask id="theScriptTask" name="Execute script" scriptFormat="juel" activiti:resultVariable="myVar"> <script>#{echo}</script> </scriptTask>脚本的结果-表达式 #{echo} 的值会在脚本完成后,设置到myVar变量中Java服务任务描述Java服务任务用来调用外部Java类图形标记Java服务任务显示为圆角矩形,左上角有一个齿轮小图标XML内容声明Java调用逻辑有四种方式:实现JavaDelegate或者ActivityBehavior执行解析代理对象的表达式调用一个方法表达式调用一个值表达式执行一个在流程执行中调用的类,需要在activiti:class属性中设置全类名:<serviceTask id="javaService" name="My Java Service Task" activiti:class="org.activiti.MyJavaDelegate" />使用表达式调用一个对象,对象必须遵循一些规则,并使用activiti:delegateExpression属性进行创建:<serviceTask id="serviceTask" activiti:delegateExpression="${delegateExpressionBean}" />delegateExpressionBean是一个实现了JavaDelegate接口的bean,定义在实例的spring容器中要执行指定的UEL方法表达式, 需要使用activiti:expression:<serviceTask id="javaService" name="My Java Service Task" activiti:expression="#{printer.printMessage()}" />方法printMessage()会调用名为printer对象的方法为表达式中的方法传递参数:<serviceTask id="javaService" name="My Java Service Task" activiti:expression="#{printer.printMessage(execution, myVar)}" />调用名为printer对象上的方法printMessage.第一个参数是DelegateExecution, 在表达式环境中默认名称为execution. 第二个参数传递的是当前流程的名为myVar的变量要执行指定的UEL方法表达式, 需要使用activiti:expression:<serviceTask id="javaService" name="My Java Service Task" activiti:expression="#{split.ready}" />ready属性的getter方法:getReady() 会作用于名为split的bean上.这个对象会被解析为流程对象和spring环境中的对象实现要在流程执行中实现一个调用的类,这个类需要实现org.activiti.engine.delegate.JavaDelegate接口,并在execute方法中提供对应的业务逻辑.当流程执行到特定阶段,会指定方法中定义好的业务逻辑,并按照默认BPMN 2.0中的方式离开节点示例:创建一个java类的例子,对流程变量中字符串转换为大写这个类需要实现org.activiti.engine.delegate.JavaDelegate接口,要求实现execute(DelegateExecution) 方法,包含的业务逻辑会被引擎调用流程实例信息:流程变量和其他信息,可以通过DelegateExecution接口访问和操作public class ToUppercase implements JavaDelegate { public void execute(DelegateExecution execution) throws Exception { String var = (String) execution.getVariable("input"); var = var.toUpperCase(); execution.setVariable("input", var); } }serviceTask定义的class只会创建一个java类的实例所有流程实例都会共享相同的类实例,并调用execute(DelegateExecution)类不能使用任何成员变量,必须是线程安全的,必须能模拟在不同线程中执行.影响着属性注入的处理方式流程定义中引用的类(activiti:class)不会在部署时实例化只有当流程第一次执行到使用类的时候,类的实例才会被创建如果找不到类,会抛出一个ActivitiException这个原因是部署环境(更确切是的classpath)和真实环境往往是不同的:当使用ant或业务归档上传到Activiti Explorer来发布流程,classpath没有包含引用的类内部实现类也可以提供实现org.activiti.engine.impl.pvm.delegate.ActivityBehavior接口的类实现可以访问更强大的ActivityExecution,它可以影响流程的流向注意: 这应该尽量避免.只有在高级情况下并且确切知道要做什么的情况下,再使用ActivityBehavior接口属性注入为代理类的属性注入数据. 支持如下类型的注入:固定的字符串表达式如果有效的话,数值会通过代理类的setter方法注入,遵循java bean的命名规范(比如fistName属性对应setFirstName(Xxx)方法)如果属性没有对应的setter方法,数值会直接注入到私有属性中一些环境的SecurityManager不允许修改私有属性,要把想注入的属性暴露出对应的setter方法来无论流程定义中的数据是什么类型,注入目标的属性类型都应该是 org.activiti.engine.delegate.Expression示例:把一个常量注入到属性中属性注入可以使用class属性在声明实际的属性注入之前,需要定义一个extensionElements的XML元素<serviceTask id="javaService" name="Java service invocation" activiti:class="org.activiti.examples.bpmn.servicetask.ToUpperCaseFieldInjected"> <extensionElements> <activiti:field name="text" stringValue="Hello World" /> </extensionElements> </serviceTask>ToUpperCaseFieldInjected类有一个text属性,类型是org.activiti.engine.delegate.Expression. 调用text.getValue(execution) 时,会返回定义的字符串Hello World可以使用长文字(比如,内嵌的email),使用activiti:string子元素:<serviceTask id="javaService" name="Java service invocation" activiti:class="org.activiti.examples.bpmn.servicetask.ToUpperCaseFieldInjected"> <extensionElements> <activiti:field name="text"> <activiti:string> Hello World </activiti:string> </activiti:field> </extensionElements> </serviceTask>可以使用表达式,实现在运行期动态解析注入的值这些表达式可以使用流程变量或spring定义的bean.服务任务中的java类实例会在所有流程实例中共享:为了动态注入属性的值,可以在org.activiti.engine.delegate.Expression中使用值和方法表达式会使用传递给execute方法的DelegateExecution参数进行解析<serviceTask id="javaService" name="Java service invocation" activiti:class="org.activiti.examples.bpmn.servicetask.ReverseStringsFieldInjected"> <extensionElements> <activiti:field name="text1"> <activiti:expression>${genderBean.getGenderString(gender)}</activiti:expression> </activiti:field> <activiti:field name="text2"> <activiti:expression>Hello ${gender == 'male' ? 'Mr.' : 'Mrs.'} ${name}</activiti:expression> </activiti:field> </ extensionElements> </ serviceTask>示例:注入表达式,并使用在当前传入的DelegateExecution解析:public class ReverseStringsFieldInjected implements JavaDelegate { private Expression text1; private Expression text2; public void execute(DelegateExecution execution) { String value1 = (String) text1.getValue(execution); execution.setVariable("var1", new StringBuffer(value1).reverse().toString()); String value2 = (String) text2.getValue(execution); execution.setVariable("var2", new StringBuffer(value2).reverse().toString()); } }可以把表达式设置成一个属性,而不是子元素:因为java类实例会被重用,注入只会发生一次,当服务任务调用第一次的时候发生注入当代码中的属性改变了,值也不会重新注入,把它们看作是不变的,不用修改它们服务任务结果服务流程返回的结果(使用表达式的服务任务)可以分配给已经存在的或新的流程变量通过指定服务任务定义的activiti:resultVariable属性来实现指定的流程变量会被服务流程的返回结果覆盖如果没有指定返回变量名,就会忽略返回结果<serviceTask id="aMethodExpressionServiceTask" activiti:expression="#{myService.doSomething()}" activiti:resultVariable="myVar" />服务流程的返回值(在myService上调用doSomething() 方法的返回值,myService可能是流程变量,也可能是spring的bean),在服务执行完成之后,会设置到名为myVar的流程变量里处理异常执行自定义逻辑时,常常需要捕获对应的业务异常,在流程内部进行处理抛出BPMN Errors:在服务任务或脚本任务的代码里抛出BPMN error:要从JavaDelegate,脚本,表达式和代理表达式中抛出名为BpmnError的特殊ActivitiExeption引擎会捕获这个异常,把它转发到对应的错误处理中:边界错误事件或错误事件子流程public class ThrowBpmnErrorDelegate implements JavaDelegate { public void execute(DelegateExecution execution) throws Exception { try { executeBusinessLogic(); } catch (BusinessException e) { throw new BpmnError("BusinessExceptionOccured"); } } }构造参数是错误代码,会被用来决定哪个错误处理器会来响应这个错误这个机制只用于业务失败,应该被流程定义中设置的边界错误事件或错误事件子流程处理. 技术上的错误应该使用其他异常类型,通常不会在流程里处理异常顺序流:内部实现类在一些异常发生时,让流程进入其他路径<serviceTask id="javaService" name="Java service invocation" activiti:class="org.activiti.ThrowsExceptionBehavior"> </serviceTask> <sequenceFlow id="no-exception" sourceRef="javaService" targetRef="theEnd" /> <sequenceFlow id="exception" sourceRef="javaService" targetRef="fixException" />这里的服务任务有两个外出顺序流:分别叫exception和no-exception. 异常出现时会使用顺序流的ID来决定流向public class ThrowsExceptionBehavior implements ActivityBehavior { public void execute(ActivityExecution execution) throws Exception { String var = (String) execution.getVariable("var"); PvmTransition transition = null; try { executeLogic(var); transition = execution.getActivity().findOutgoingTransition("no-exception"); } catch (Exception e) { transition = execution.getActivity().findOutgoingTransition("exception"); } execution.take(transition); } }JavaDelegate使用Activiti服务需要在Java服务任务中使用Activiti服务的场景: 比如,通过RuntimeService启动流程实例,而callActivity不满足需求org.activiti.engine.delegate.DelegateExecution允许通过 org.activiti.engine.EngineServices接口直接获得这些服务:public class StartProcessInstanceTestDelegate implements JavaDelegate { public void execute(DelegateExecution execution) throws Exception { RuntimeService runtimeService = execution.getEngineServices().getRuntimeService(); runtimeService.startProcessInstanceByKey("myProcess"); } }所有activiti服务的API都可以通过这个接口获得使用这些API调用出现的所有数据改变,都是在当前事务中在例如spring和CDI这样的依赖注入环境也会起作用,无论是否启用了JTA数据源示例: 下面的代码功能与上面的代码一致,这是RuntimeService是通过依赖注入获得,而不是通过org.activiti.engine.EngineServices接口@Component("startProcessInstanceDelegate") public class StartProcessInstanceTestDelegateWithInjection { @Autowired private RuntimeService runtimeService; public void startProcess() { runtimeService.startProcessInstanceByKey("oneTaskProcess"); } }因为服务调用是在当前事务里,数据的产生或改变,在服务任务执行完之前,还没有提交到数据库.所以API对于数据库数据的操作,意味着未提交的操作在服务任务的API调用中都是不可见的WebService任务描述WebService任务可以用来同步调用一个外部的WebService图形标记WebService任务与Java服务任务显示效果一样(圆角矩形,左上角有一个齿轮小图标)XML内容要使用WebService需要导入操作和类型,可以使用import标签来指定WebService的WSDL<import importType="http://schemas.xmlsoap.org/wsdl/" location="http://localhost:63081/counter?wsdl" namespace="http://webservice.activiti.org/" />声明告诉activiti导入WSDL定义,但没有创建itemDefinition和message假设想调用一个名为prettyPrint的方法,必须创建为请求和响应信息对应的message和itemDefinition<message id="prettyPrintCountRequestMessage" itemRef="tns:prettyPrintCountRequestItem" /> <message id="prettyPrintCountResponseMessage" itemRef="tns:prettyPrintCountResponseItem" /> <itemDefinition id="prettyPrintCountRequestItem" structureRef="counter:prettyPrintCount" /> <itemDefinition id="prettyPrintCountResponseItem" structureRef="counter:prettyPrintCountResponse" />在申请服务任务之前,必须定义实际引用WebService的BPMN接口和操作基本上,定义接口和必要的操作.对每个操作都会重用上面定义的信息作为输入和输出示例:定义了counter接口和prettyPrintCountOperation操作: <interface name="Counter Interface" implementationRef="counter:Counter"> <operation id="prettyPrintCountOperation" name="prettyPrintCount Operation" implementationRef="counter:prettyPrintCount"> <inMessageRef>tns:prettyPrintCountRequestMessage</inMessageRef> <outMessageRef>tns:prettyPrintCountResponseMessage</outMessageRef> </operation> </interface>然后定义WebService任务,使用WebService实现,并引用WebService操作<serviceTask id="webService" name="Web service invocation" implementation="##WebService" operationRef="tns:prettyPrintCountOperation">WebService任务IO规范每个WebService任务可以定义任务的输入输出IO规范<ioSpecification> <dataInput itemSubjectRef="tns:prettyPrintCountRequestItem" id="dataInputOfServiceTask" /> <dataOutput itemSubjectRef="tns:prettyPrintCountResponseItem" id="dataOutputOfServiceTask" /> <inputSet> <dataInputRefs>dataInputOfServiceTask</dataInputRefs> </inputSet> <outputSet> <dataOutputRefs>dataOutputOfServiceTask</dataOutputRefs> </outputSet> </ioSpecification>WebService任务数据输入关联指定数据输入关联有两种方式:使用表达式使用简化方式使用表达式指定数据输入关联: 需要定义来源和目的item,并指定每个item属性之间的对应关系:<dataInputAssociation> <sourceRef>dataInputOfProcess</sourceRef> <targetRef>dataInputOfServiceTask</targetRef> <assignment> <from>${dataInputOfProcess.prefix}</from> <to>${dataInputOfServiceTask.prefix}</to> </assignment> <assignment> <from>${dataInputOfProcess.suffix}</from> <to>${dataInputOfServiceTask.suffix}</to> </assignment> </dataInputAssociation>分配item的前缀和后缀使用简化方式指定数据输入关联: sourceRef元素是activiti的变量名,targetRef元素是item定义的一个属性:<dataInputAssociation> <sourceRef>PrefixVariable</sourceRef> <targetRef>prefix</targetRef> </dataInputAssociation> <dataInputAssociation> <sourceRef>SuffixVariable</sourceRef> <targetRef>suffix</targetRef> </dataInputAssociation>PrefixVariable变量的值分配给prefix属性,把SuffixVariable变量的值分配给suffix属性WebService任务数据输出关联指定数据输出关联有两种方式:使用表达式使用简化方式使用表达式指定数据输出关联: 需要定义目的变量和来源表达式<dataOutputAssociation> <targetRef>dataOutputOfProcess</targetRef> <transformation>${dataOutputOfServiceTask.prettyPrint}</transformation> </dataOutputAssociation>方法和数据输入关联完全一样使用简化方式指定数据输出关联: sourceRef元素是item定义的一个属性,targetRef元素是activiti的变量名<dataOutputAssociation> <sourceRef>prettyPrint</sourceRef> <targetRef>OutputVariable</targetRef> </dataOutputAssociation>方法和数据输入关联完全一样业务规则任务描述业务规则任务用来同步执行一个或多个规则Activiti使用drools规则引擎执行业务规则:包含业务规则的.drl文件必须和流程定义一起发布流程定义里包含了执行这些规则的业务规则任务流程使用的所有.drl文件都必须打包在流程BAR文件里如果想要自定义规则任务的实现: 想用不同方式使用drools,或者使用完全不同的规则引擎.你可以使用BusinessRuleTask上的class或表达式属性图形标记业务规则任务是一个圆角矩形,左上角使用一个表格小图标进行显示XML内容要执行部署流程定义的BAR文件中的一个或多个业务规则,需要定义输入和输出变量:对于输入变量定义,可以使用逗号分隔的一些流程变量输出变量定义只包含一个变量名,会把执行业务规则后返回的对象保存到对应的流程变量中注意: 结果变量会包含一个对象列表,如果没有指定输出变量名称,默认会使用 org.activiti.engine.rules.OUTPUT<process id="simpleBusinessRuleProcess"> <startEvent id="theStart" /> <sequenceFlow sourceRef="theStart" targetRef="businessRuleTask" /> <businessRuleTask id="businessRuleTask" activiti:ruleVariablesInput="${order}" activiti:resultVariable="rulesOutput" /> <sequenceFlow sourceRef="businessRuleTask" targetRef="theEnd" /> <endEvent id="theEnd" /> </process>业务规则任务也可以配置成只执行部署的.drl文件中的一些规则.这时要设置逗号分隔的规则名,只会执行rule1和rule2:<businessRuleTask id="businessRuleTask" activiti:ruleVariablesInput="${order}" activiti:rules="rule1, rule2" />定义哪些规则不用执行:除了rule1和rule2以外,所有部署到流程定义同一个BAR文件中的规则都会执行:<businessRuleTask id="businessRuleTask" activiti:ruleVariablesInput="${order}" activiti:rules="rule1, rule2" exclude="true" />可以用一个选项修改BusinessRuleTask的实现:<businessRuleTask id="businessRuleTask" activiti:class="${MyRuleServiceDelegate}" />BusinessRuleTask的功能和ServiceTask一样,但是使用BusinessRuleTask的图标来表示 在这里要执行业务规则邮件任务Activiti强化了业务流程,支持自动邮件任务:可以发送邮件给一个或多个参与者,包括支持cc,bcc,HTML内容等等邮件任务不是BPMN 2.0规范定义的官方任务,Activiti中邮件任务是用专门的服务任务实现的邮件服务器配置Activiti引擎要通过支持SMTP功能的外部邮件服务器发送邮件为了实际发送邮件,引擎穾知道如何访问邮件服务器.下面的配置可以设置到activiti.cfg.xml配置文件中:属性是否必须描述mailServerHost否邮件服务器的主机名(比如:mail.mycorp.com).默认为localhostmailServerPort是如果没有使用默认端口邮件服务器上的SMTP传输端口.默认为25mailServerDefaultFrom否如果用户没有指定发送邮件的邮件地址,默认设置的发送者的邮件地址。默认为activiti@activiti.orgmailServerUsername如果服务器需要一些邮件服务器需要认证才能发送邮件.默认不设置mailServerPassword如果服务器需要一些邮件服务器需要认证才能发送邮件.默认不设置mailServerUseSSL如果服务器需要一些邮件服务器需要ssl交互.默认为falsemailServerUseTLS如果服务器需要一些邮件服务器(比如gmail)需要支持TLS.默认为false定义一个邮件任务邮件任务是一个专用的服务任务, 这个服务任务的type设置为mail<serviceTask id="sendMail" activiti:type="mail">邮件任务是通过属性注入进行配置的.所有这些属性都可以使用EL表达式,可以在流程执行中解析. 下面的属性都可以设置:属性是否必须描述to是邮件的接受者.可以使用逗号分隔多个接受者from否邮件发送者的地址.如果不提供,会使用默认配置的地址subject否邮件的主题cc否邮件抄送人.可以使用逗号分隔多个接收者bcc否邮件暗送人.可以使用逗号分隔多个接收者charset否可以修改邮件的字符集,对很多非英语语言是必须设置的html否作为邮件内容的HTMLtext否邮件的内容.,在需要使用原始文字(非富文本)的邮件时使用.可以与html一起使用,对于不支持富文本的邮件客户端.客户端会降级到仅显示文本的方式htmlVar否使用对应的流程变量作为e-mail的内容.和html的不同之处是内容中包含的表达式会在mail任务发送之前被替换掉textVar否使用对应的流程变量作为e-mail的纯文本内容.和text的不同之处是内容中包含的表达式会在mail任务发送之前被替换掉ignoreException否处理邮件失败时,是否忽略异常,不抛出ActivitiException,默认为falseexceptionVariableName否当设置了ignoreException=true处理email时不抛出异常,可以指定一个变量名来存储失败信息实例邮件任务的使用示例:<serviceTask id="sendMail" activiti:type="mail"> <extensionElements> <activiti:field name="from" stringValue="order-shipping@thecompany.com" /> <activiti:field name="to" expression="${recipient}" /> <activiti:field name="subject" expression="Your order ${orderId} has been shipped" /> <activiti:field name="html"> <activiti:expression> <![CDATA[ <html> <body> Hello ${male ? 'Mr.' : 'Mrs.' } ${recipientName},<br/><br/> As of ${now}, your order has been <b>processed and shipped</b>.<br/><br/> Kind regards,<br/> TheCompany. </body> </html> ]]> </activiti:expression> </activiti:field> </extensionElements> </serviceTask>Mule任务Mule任务可以向Mule发送消息,用来强化Activiti的集成能力Mule任务不是BPMN 2.0规范定义的官方任务,Activiti中Mule任务是用专门的服务任务实现的定义Mule任务Mule任务是一个专用的服务任务, 服务任务的type设置为mule<serviceTask id="sendMule" activiti:type="mule">Mule任务是通过属性注入进行配置的.属性使用EL表达式, 可以在流程执行中解析属性是否必须描述endpointUrl是需要调用的Mule终端language是要使用解析荷载表达式(payloadExpression)属性的语言payloadExpression是作为消息荷载的表达式resultVariable否将要保存调用结果的变量名称实例Mule任务的使用示例: <extensionElements> <activiti:field name="endpointUrl"> <activiti:string>vm://in</activiti:string> </activiti:field> <activiti:field name="language"> <activiti:string>juel</activiti:string> </activiti:field> <activiti:field name="payloadExpression"> <activiti:string>"hi"</activiti:string> </activiti:field> <activiti:field name="resultVariable"> <activiti:string>theVariable</activiti:string> </activiti:field> </extensionElements>Camel任务Camel任务可以从Camel发送和接收消息,用来强化activiti的集成功能Camel任务不是BPMN 2.0规范定义的官方任务,Camel任务时由专用的服务任务实现的使用Camel任务功能,要把Activiti Camel包含到项目中定义Camel任务Camel任务是一个专用的服务任务, 服务任务的type设置为camel<serviceTask id="sendCamel" activiti:type="camel">流程定义只需要在服务任务中定义Camel类型集成逻辑都会代理给Camel容器默认Activiti引擎会在spring容器中查找camelContext bean.camelContext定义了camel容器加载的路由规则路由规则是既可以从指定的java包下加载, 也可以通过spring配置直接定义路由规则<camelContext id="camelContext" xmlns="http://camel.apache.org/schema/spring"> <packageScan> <package>org.activiti.camel.route</package> </packageScan> </camelContext>定义多个Camel环境bean,并且使用不同的bean名称. 可以重载CamelTask的定义<serviceTask id="serviceTask1" activiti:type="camel"> <extensionElements> <activiti:field name="camelContext" stringValue="customCamelContext" /> </extensionElements> </serviceTask>Camel调用为了激活一个特定的Camel路由:需要一个Spring环境,包含SimpleCamelCallRoute的路由的类文件,放在packageScan标签的扫描目录下<camelContext id="camelContext" xmlns="http://camel.apache.org/schema/spring"> <packageScan> <package>org.activiti.camel.examples.simpleCamelCall</package> </packageScan> </camelContext>路由的定义:public class SimpleCamelCallRoute extends RouteBuilder { @Override public void configure() throws Exception { from("activiti:SimpleCamelCallProcess:simpleCall").to("log: org.activiti.camel.examples.SimpleCamelCall"); } }这个规则用于打印消息体终端的格式包含三部分:终端URL: 引用activiti终端SimpleCamelCallProcess: 流程名simpleCall: 流程中的Camel服务配置好规则后,可以让Camel进行使用.工作流如下:<process id="SimpleCamelCallProcess"> <startEvent id="start"/> <sequenceFlow id="flow1" sourceRef="start" targetRef="simpleCall"/> <serviceTask id="simpleCall" activiti:type="camel"/> <sequenceFlow id="flow2" sourceRef="simpleCall" targetRef="end"/> <endEvent id="end"/> </process>在serviceTask部分,注明服务的类型是Camel, 目标规则名为simpleCall. 这与上面的Activiti终端相匹配.初始化流程后,会看到一个空的日志乒乓实例Camel和Activiti之间需要交互,向Camel发送和接收数据发送一个字符串,把变量里的消息发送给Camel,Camel进行一些处理,然后返回结果:@Deployment public void testPingPong() { Map<String, Object> variables = new HashMap<String, Object>(); variables.put("input", "Hello"); Map<String, String> outputMap = new HashMap<String, String>(); variables.put("outputMap", outputMap); runtimeService.startProcessInstanceByKey("PingPongProcess", variables); assertEquals(1, outputMap.size()); assertNotNull(outputMap.get("outputValue")); assertEquals("Hello World", outputMap.get("outputValue")); }变量input是Camel规则的实际输入 ,outputMap会记录camel返回的结果<process id="PingPongProcess"> <startEvent id="start"/> <sequenceFlow id="flow1" sourceRef="start" targetRef="ping"/> <serviceTask id="ping" activiti:type="camel"/> <sequenceFlow id="flow2" sourceRef="ping" targetRef="saveOutput"/> <serviceTask id="saveOutput" activiti:class="org.activiti.camel.examples.pingPong.SaveOutput" /> <sequenceFlow id="flow3" sourceRef="saveOutput" targetRef="end"/> <endEvent id="end"/> </process>SaveOuput这个serviceTask, 会把Output变量的值从上下文保存到OutputMap中变量提交给Camel的方法是由CamelBehavior控制的.配置一个期望的Camel操作:<serviceTask id="serviceTask1" activiti:type="camel"> <extensionElements> <activiti:field name="camelBehaviorClass" stringValue="org.activiti.camel.impl.CamelBehaviorCamelBodyImpl" /> </extensionElements> </serviceTask>如果特别指定一个行为,就会使用org.activiti.camel.impl.CamelBehaviorDefaultImpl. 这个行为会把变量复制成名称相同的Camel属性在返回时,无论选择什么行为,如果camel消息体是一个map,每个元素都会复制成一个变量.否则整个对象会复制到指定名称为camelBody的变量中@Override public void configure() throws Exception { from("activiti:PingPongProcess:ping").transform().simple("${property.input} World"); } 在这个规则中,字符串world会被添加到input属性的后面,结果会写入消息体这时可以检查javaServiceTask中的camelBody变量,复制到outputMap中,并在testcase进行判断在启动的所有camel规则中 ,流程实例ID会复制到Camel的名为PROCESS_ID_PROPERTY的属性中,后续可以用来关联流程实例和Camel规则,也可以在camel规则中直接使用Activiti中可以使用三种不同Camel的行为: 可以通过在规则URL中指定来实现覆盖from("activiti:asyncCamelProcess:serviceTaskAsync2?copyVariablesToProperties=true").Activiti变量如何传递给camel:行为URL描述CamelBehaviorDefaultImplcopyVariablesToProperties把Activiti变量复制为Camel属性CamelBehaviorCamelBodyImplcopyCamelBodyToBody只把名为"camelBody"Activiti变量复制成Camel的消息体CamelBehaviorBodyAsMapImplcopyVariablesToBodyAsMap把Activiti的所有变量复制到一个map里,作为Camel的消息体Camel的变量如何返回给Activiti,只能配置在规则URL中:URL描述默认如果Camel消息体是一个map,把每个元素复制成Activiti的变量.否则把整个Camel消息体作为Activiti的camelBody变量copyVariablesFromProperties把Camel属性以相同名称复制为Activiti变量copyCamelBodyToBodyAsString和默认一样,但是如果camel消息体不是map时,先把它转换成字符串,再设置为camelBodycopyVariablesFromHeader额外把Camel头部以相同名称复制成Activiti变量异步乒乓实例同步的乒乓实例,流程会等到Camel规则返回之后才会停止某些情况下,需要Activiti工作流继续运行,就要使用camelServiceTask的异步功能通过设置camelServiceTask的async属性来启用这个功能<serviceTask id="serviceAsyncPing" activiti:type="camel" activiti:async="true"/>Camel规则会被Activiti的jobExecutor异步执行当在Camel规则中定义了一个队列,Activiti流程会在camelServiceTask执行时继续运行camel规则以完全异步的方式执行可以使用一个receiveTask等待camelServiceTask的返回值,流程实例会等到接收一个来自camel的signal:<receiveTask id="receiveAsyncPing" name="Wait State" />在Camel中可以发送一个signal给流程实例,通过对应的Activiti终端发送消息:from("activiti:asyncPingProcess:serviceAsyncPing").to("activiti:asyncPingProcess:receiveAsyncPing");在Activiti终端中,会使用冒号分隔的三个部分:常量字符串activiti流程名称接收任务名Camel规则中实例化工作流一般情况下,Activiti工作流会先启动,然后在流程中启动Camel规则在已经启动的Camel规则中启动一个工作流,会触发一个receiveTask十分类似,除了最后的部分.实例规则如下:from("direct:start").to("activiti:camelProcess");url有两个部分:常量字符串activiti流程的名称流程已经部署完成,并且是可以启动的手工任务描述手工任务定义了BPMN引擎外部的任务表示工作需要某人完成,而引擎不需要知道, 也没有对应的系统和UI接口对于BPMN引擎而言,手工任务是直接通过的活动,流程到达它之后会自动向下执行图形标记手工任务显示为普通任务(圆角矩形),左上角是一个手型小图标XML内容<manualTask id="myManualTask" name="Call client for more information" />Java接收任务描述接收任务是一个简单任务,会等待对应消息的到达当流程达到接收任务,流程状态会保存到存储里.意味着流程会等待在这个等待状态,直到引擎接收了一个特定的消息,触发流程穿过接收任务继续执行图形标记接收任务显示为一个任务(圆角矩形),右上角有一个消息小标记.消息是白色的(黑色图标表示发送语义)XML内容<receiveTask id="waitState" name="wait" /> 要在接收任务等待的流程实例继续执行,可以调用runtimeService.signal(executionId), 传递接收任务上流程的id:ProcessInstance pi = runtimeService.startProcessInstanceByKey("receiveTask"); Execution execution = runtimeService.createExecutionQuery() .processInstanceId(pi.getId()) .activityId("waitState") .singleResult(); assertNotNull(execution); runtimeService.signal(execution.getId());Shell任务描述Shell任务可以执行Shell脚本和命令Shell任务不是BPMN 2.0规范定义的官方任务,没有对应的图标定义Shell任务Shell任务是一个专用的服务任务,这个服务任务的type设置为shell<serviceTask id="shellEcho" activiti:type="shell">Shell任务使用属性注入进行配置,所有属性都可以包含EL表达式, 会在流程执行过程中解析属性是否必须类型描述默认值command是String执行的shell命令 arg0-5否String参数0至5 wait否true/false是否需要等待到shell进程结束trueredirectError否true/false把标准错误打印到标准流中falsecleanEnv否true/falseShell进行不继承当前环境falseoutputVariable否String保存输出的变量名不会记录输出结果errorCodeVariable否String包含结果错误代码的变量名不会注册错误级别directory否StringShell进程的默认目录当前目录应用实例执行shell脚本cmd /c echo EchoTest, 等到它结束,再把输出结果保存到resultVar中:<serviceTask id="shellEcho" 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="EchoTest" /> <activiti:field name="wait" stringValue="true" /> <activiti:field name="outputVariable" stringValue="resultVar" /> </extensionElements> </serviceTask> 执行监听器执行监听器可以在流程定义中发生了某个事件时执行外部Java代码或执行表达式执行监听器可以捕获的事件有:流程实例的启动和结束选中一条连线节点的开始和结束网关的开始和结束中间事件的开始和结束开始时间结束或结束事件开始下面的流程定义定义了3个流程监听器: <process id="executionListenersProcess"> <extensionElements> <activiti:executionListener class="org.activiti.examples.bpmn.executionlistener.ExampleExecutionListenerOne" event="start" /> </extensionElements> <startEvent id="theStart" /> <sequenceFlow sourceRef="theStart" targetRef="firstTask" /> <userTask id="firstTask" /> <sequenceFlow sourceRef="firstTask" targetRef="secondTask"> <extensionElements> <activiti:executionListener class="org.activiti.examples.bpmn.executionListener.ExampleExecutionListenerTwo" /> </extensionElements> </sequenceFlow> <userTask id="secondTask" > <extensionElements> <activiti:executionListener expression="${myPojo.myMethod(execution.event)}" event="end" /> </extensionElements> </userTask> <sequenceFlow sourceRef="secondTask" targetRef="thirdTask" /> <userTask id="thirdTask" /> <sequenceFlow sourceRef="thirdTask" targetRef="theEnd" /> <endEvent id="theEnd" /> </process>第一个流程监听器监听流程开始. 监听器是一个外部Java类(例如ExampleExecutionListenerOne),需要实现org.activiti.engine.delegate.ExecutionListener接口.当事件发生时(end事件),会调用notify(ExecutionListenerExecution execution) 方法:public class ExampleExecutionListenerOne implements ExecutionListener { public void notify(ExecutionListenerExecution execution) throws Exception { execution.setVariable("variableSetInExecutionListener", "firstValue"); execution.setVariable("eventReceived", execution.getEventName()); } }也可以使用实现org.activiti.engine.delegate.JavaDelegate接口的代理类(代理类可以在结构中重用,比如serviceTask的代理)第二个流程监听器在连线执行时调用. 注意这个listener元素不能定义event, 因为连线只能触发take事件,为连线定义的监听器的event属性会被忽略第三个流程监听器在节点secondTask结束时调用. 使用expression代替class来在事件触发时执行或调用<activiti:executionListener expression="${myPojo.myMethod(execution.eventName)}" event="end" />流程变量可以处理和使用流程实现对象有一个保存事件名称的属性,在方法中使用execution.eventName获的事件名称流程监听器也支持delegateExpression, 和服务任务相同<activiti:executionListener event="start" delegateExpression="${myExecutionListenerBean}" />脚本流程监听器org.activiti.engine.impl.bpmn.listener.ScriptExecutionListener可以为某个流程监听事件执行一段脚本<activiti:executionListener event="start" class="org.activiti.engine.impl.bpmn.listener.ScriptExecutionListener" > <activiti:field name="script"> <activiti:string> def bar = "BAR"; // local variable foo = "FOO"; // pushes variable to execution context execution.setVariable("var1", "test"); // test access to execution instance bar // implicit return value </activiti:string> </activiti:field> <activiti:field name="language" stringValue="groovy" /> <activiti:field name="resultVariable" stringValue="myVar" /> <activiti:executionListener>流程监听器的属性注入流程监听器时,可以配置class属性,使用属性注入.这和使用服务任务属性注入相同使用属性注入的流程监听器的流程示例:<process id="executionListenersProcess"> <extensionElements> <activiti:executionListener class="org.activiti.examples.bpmn.executionListener.ExampleFieldInjectedExecutionListener" event="start"> <activiti:field name="fixedValue" stringValue="Yes, I am " /> <activiti:field name="dynamicValue" expression="${myVar}" /> </activiti:executionListener> </extensionElements> <startEvent id="theStart" /> <sequenceFlow sourceRef="theStart" targetRef="firstTask" /> <userTask id="firstTask" /> <sequenceFlow sourceRef="firstTask" targetRef="theEnd" /> <endEvent id="theEnd" /> </process> public class ExampleFieldInjectedExecutionListener implements ExecutionListener { private Expression fixedValue; private Expression dynamicValue; public void notify(ExecutionListenerExecution execution) throws Exception { execution.setVariable("var", fixedValue.getValue(execution).toString() + dynamicValue.getValue(execution).toString()); } }ExampleFieldInjectedExecutionListener类串联了两个注入的属性(一个是固定的,一个是动态的),把他们保存到流程变量var中@Deployment(resources = {"org/activiti/examples/bpmn/executionListener/ExecutionListenersFieldInjectionProcess.bpmn20.xml"}) public void testExecutionListenerFieldInjection() { Map<String, Object> variables = new HashMap<String, Object>(); variables.put("myVar", "listening!"); ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("executionListenersProcess", variables); Object varSetByListener = runtimeService.getVariable(processInstance.getId(), "var"); assertNotNull(varSetByListener); assertTrue(varSetByListener instanceof String); // Result is a concatenation of fixed injected field and injected expression assertEquals("Yes, I am listening!", varSetByListener); }任务监听器任务监听器可以在发生对应的任务相关事件时执行自定义Java逻辑或表达式任务监听器只能添加到流程定义中的用户任务中. 必须定义在BPMN 2.0 extensionElements的子元素中,并使用activiti命名空间, 因为任务监听器是activiti独有的结构<userTask id="myTask" name="My Task" > <extensionElements> <activiti:taskListener event="create" class="org.activiti.MyTaskCreateListener" /> </extensionElements> </userTask>任务监听器支持的属性:event(必选): 任务监听器会被调用的任务类型create: 任务创建并设置所有属性后触发assignment: 任务分配给一些人时触发.当流程到达userTask,assignment事件会在create事件之前发生(当获得create时间时,我们想获得任务的所有属性,包括执行人)complete: 当任务完成,并尚未从运行数据中删除时触发delete: 只在任务删除之前发生,在通过completeTask正常完成时,也会执行class: 必须调用的代理类, 类要实现org.activiti.engine.delegate.TaskListener接口 public class MyTaskCreateListener implements TaskListener { public void notify(DelegateTask delegateTask) { // Custom logic goes here } }可以使用属性注入把流程变量或执行传递给代理类代理类的实例是在部署时创建的,所有流程实例都会共享同一个实例expression: 指定事件发生时执行的表达式.无法同时与class属性一起使用. 可以把DelegateTask对象和事件名称(task.eventName)作为参数传递给调用的对象<activiti:taskListener event="create" expression="${myObject.callMethod(task, task.eventName)}" />delegateExpression: 指定一个表达式,解析一个实现了TaskListener接口的对象,与服务任务一致 <activiti:taskListener event="create" delegateExpression="${myTaskListenerBean}" />脚本任务监听器org.activiti.engine.impl.bpmn.listener.ScriptTaskListener可以为任务监听器事件执行脚本<activiti:taskListener event="complete" class="org.activiti.engine.impl.bpmn.listener.ScriptTaskListener" > <activiti:field name="script"> <activiti:string> def bar = "BAR"; // local variable foo = "FOO"; // pushes variable to execution context task.setOwner("kermit"); // test access to task instance bar // implicit return value </activiti:string> </activiti:field> <activiti:field name="language" stringValue="groovy" /> <activiti:field name="resultVariable" stringValue="myVar" /> <activiti:taskListener>多实例(循环)描述多实例节点是在业务流程中定义重复环节的方法多实例和循环是一样的:它可以根据给定的集合,为每个元素执行一个环节甚至一个完整的子流程,既可以顺序依次执行也可以并发同步执行多实例是在一个普通的节点上添加了额外的属性定义(所以叫做'多实例特性),这样运行时节点就会执行多次可以设置成多实例节点的节点:User TaskScript TaskJava Service TaskWebService TaskBusiness Rule TaskEmail TaskManual TaskReceive Task(Embedded) Sub-Process [(嵌入子)流程]Call Activity [调用子流程]网关和事件不能设置多实例每个上级流程为每个实例创建分支时都要提供下列变量:nrOfInstances: 实例总数nrOfActiveInstances: 当前活动,还没完成的实例数量. 顺序执行的多实例,值一直为1nrOfCompletedInstances: 已经完成实例的数目通过execution.getVariable(Xx) 方法获得这些变量每个创建的分支都会有分支级别的本地变量(例如其他实例不可见,不会保存到流程实例级别):loopCounter- 特定实例的在循环的索引值使用activiti的elementIndexVariable属性修改loopCounter的变量名图形标记多实例的节点,会在节点底部显示三条短线.三条竖线表示实例会并行执行. 三条横线表示顺序执行XML内容要把一个节点设置为多实例,节点xml元素必须设置一个multiInstanceLoopCharacteristics子元素<multiInstanceLoopCharacteristics isSequential="false|true"> ... </multiInstanceLoopCharacteristics>isSequential属性表示节点是进行顺序执行还是并行执行实例的数量会在进入节点时计算一次:一种方法是使用loopCardinality子元素可以使用loopCardinality子元素中直接指定一个数字<multiInstanceLoopCharacteristics isSequential="false|true"> <loopCardinality>5</loopCardinality> </multiInstanceLoopCharacteristics> 也可以使用**loopCardinality**子元素中结果为整数的表达式 ```xml <multiInstanceLoopCharacteristics isSequential="false|true"> <loopCardinality>${nrOfOrders-nrOfCancellations}</loopCardinality> </multiInstanceLoopCharacteristics> ```另一个方法是通过loopDataInputRef子元素,设置一个类型为集合的流程变量名.对于集合中的每个元素,都会创建一个实例.也可以通过inputDataItem子元素指定集合<userTask id="miTasks" name="My Task ${loopCounter}" activiti:assignee="${assignee}"> <multiInstanceLoopCharacteristics isSequential="false"> <loopDataInputRef>assigneeList</loopDataInputRef> <inputDataItem name="assignee" /> </multiInstanceLoopCharacteristics> </userTask>假设assigneeList变量包含这些值[kermit, gonzo, foziee],三个用户任务会同时创建.每个分支都会拥有一个用名为assignee的流程变量,这个变量会包含集合中的对应元素,上面是用来设置用户任务的分配者loopDataInputRef和inputDataItem的缺点:名字难于记忆根据BPMN 2.0格式定义 ,不能包含表达式在activiti中可以在multiInstanceCharacteristics中设置collection和elementVariable<userTask id="miTasks" name="My Task" activiti:assignee="${assignee}"> <multiInstanceLoopCharacteristics isSequential="true" activiti:collection="${myService.resolveUsersForTask()}" activiti:elementVariable="assignee" > </multiInstanceLoopCharacteristics> </userTask>多实例节点在所有实例都完成时才会结束可以指定一个表达式在每个实例结束时执行,如果表达式返回true,所有其它的实例都会销毁,多实例节点也会结束.流程会继续执行. 表达式必须定义在completionCondition子元素中<userTask id="miTasks" name="My Task" activiti:assignee="${assignee}"> <multiInstanceLoopCharacteristics isSequential="false" activiti:collection="assigneeList" activiti:elementVariable="assignee" > <completionCondition>${nrOfCompletedInstances/nrOfInstances >= 0.6 }</completionCondition> </multiInstanceLoopCharacteristics> </userTask>assigneeList集合的每个元素都会创建一个并行的实例,当60%的任务完成时,其他任务就会删除,流程继续执行边界事件和多实例多实例是一个普通节点,可以在边缘使用边界事件对于中断型边界事件,当捕获事件时,所有激活的实例都会销毁子流程的所有实例都会在定时器触发时销毁,无论有多少实例,也不论内部节点没有完成补偿处理器描述如果一个节点用来补偿另一个节点的业务, 可以声明为一个补偿处理器补偿处理器不包含普通的流,只在补偿事件触发时执行补偿处理器不能包含进入和外出顺序流补偿处理器必须使用直接关联分配给一个补偿边界事件图形标记节点是补偿处理器,补偿事件图标会显示在中间底部区域补偿处理器图形示例:一个服务任务,附加了一个补偿边界事件,并分配了一个补偿处理器.注意cancel hotel reservation服务任务中间底部区域显示的补偿处理器图标XML内容声明作为补偿处理器的节点,需要把isForCompensation设置为true:<serviceTask id="undoBookHotel" isForCompensation="true" activiti:class="..."> </serviceTask>

org.apache.axis.ConfigurationException: Service not found: docb_assemwml org.apache.axis.ConfigurationException: Service not found: docb_assemwml at com.adobe.idp.dsc.provider.impl.soap.axis.AdobeAxisServiceRegistry.getService(AdobeAxisServiceRegistry.java:137) at com.adobe.idp.dsc.provider.impl.soap.axis.AdobeAxisServiceRegistry.getService(AdobeAxisServiceRegistry.java:196) at com.adobe.idp.dsc.provider.impl.soap.axis.AdobeAxisEngineConfiguration.getService(AdobeAxisEngineConfiguration.java:93) at org.apache.axis.AxisEngine.getService(AxisEngine.java:311) at org.apache.axis.MessageContext.setTargetService(MessageContext.java:756) at com.adobe.idp.dsc.provider.impl.soap.axis.handler.AdobeAxisURLMapper.invoke(AdobeAxisURLMapper.java:71) at org.apache.axis.strategies.InvocationStrategy.visit(InvocationStrategy.java:32) at org.apache.axis.SimpleChain.doVisiting(SimpleChain.java:118) at org.apache.axis.SimpleChain.invoke(SimpleChain.java:83) at org.apache.axis.server.AxisServer.invoke(AxisServer.java:239) at org.apache.axis.transport.http.AxisServlet.doPost(AxisServlet.java:699) at javax.servlet.http.HttpServlet.service(HttpServlet.java:637) at org.apache.axis.transport.http.AxisServletBase.service(AxisServletBase.java:327) at javax.servlet.http.HttpServlet.service(HttpServlet.java:717) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206) at com.adobe.idp.dsc.provider.impl.soap.axis.InvocationFilter.doFilter(InvocationFilter.java:43) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206) at com.adobe.idp.um.auth.filter.CSRFFilter.doFilter(CSRFFilter.java:86) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206) at org.jboss.web.tomcat.filters.ReplyHeaderFilter.doFilter(ReplyHeaderFilter.java:96) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206) at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:235) at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:191) at org.jboss.web.tomcat.security.SecurityAssociationValve.invoke(SecurityAssociationValve.java:183) at org.jboss.web.tomcat.security.JaccContextValve.invoke(JaccContextValve.java:95) at org.jboss.web.tomcat.security.SecurityContextEstablishmentValve.process(SecurityContextEstablishmentValve.java:126) at org.jboss.web.tomcat.security.SecurityContextEstablishmentValve.invoke(SecurityContextEstablishmentValve.java:70) at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:127) at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102) at org.jboss.web.tomcat.service.jca.CachedConnectionValve.invoke(CachedConnectionValve.java:158) at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109) at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:330) at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:829) at org.apache.coyote.http11.Http11ProtocolH t t p 11 C o n n e c t i o n H a n d l e r . p r o c e s s ( H t t p 11 P r o t o c o l . j a v a : 598 ) a t o r g . a p a c h e . t o m c a t . u t i l . n e t . J I o E n d p o i n t Http11ConnectionHandler.process(Http11Protocol.java:598) at org.apache.tomcat.util.net.JIoEndpointHttp11ConnectionHandler.process(Http11Protocol.java:598)atorg.apache.tomcat.util.net.JIoEndpointWorker.run(JIoEndpoint.java:451) at java.lang.Thread.run(Thread.java:662)</用试用版生成的PDF 带了水印，有意思。

mongo不知道怎么自己挂了，重启后又好了，过会又挂，没查到具体原因本来可以用supervisor，不过占用内容有点多，服务器扛不住，所以自己写脚本监控监控代码/opt/monitor/monitor-mongo.sh# 检查mongo是否还在进程中 count=`ps aux|grep mongo| grep -v grep |wc -l` echo $count now=$(date "+%Y-%m-%d %H:%M:%S") if [ $count > 0 ] then echo $now "服务正常" else echo $now "重启服务" service mongod start fi配置crontab,每30分钟检查一次*/30 * * * * cd /opt/monitor && bash monitor-mongo.sh >> monitor-mongo.log

1、运行php文件demo.php<?php echo 'hello php' . PHP_EOL;运行，-f 参数可省略$ php -f demo.php hello php $ php demo.php hello php2、执行php代码片段$ php -r "echo 'hello php' . PHP_EOL;" hello php3、运行php shell$ php -a php > echo 'hello php' . PHP_EOL; hello php4、作为脚本执行demo.php#!/usr/bin/php <?php echo 'hello php' . PHP_EOL;执行$ chmod +x ./demo.php # 赋予执行权限 $ ./demo.php hello php参考PHP 常用命令行

介绍通过一个完整例子，在 Gin 框架中，根据环境区分配置文件。也就是如何在【测试】，【线上】等环境中，读取不同的配置文件。我们将会使用 rk-boot 来启动 Gin 框架微服务。请访问如下地址获取完整教程：https://rkdocs.netlify.app/cn安装go get github.com/rookie-ninja/rk-boot快速开始我们会创建 config/beijing.yaml, config/shanghai.yaml, config/default.yaml 三个配置文件，然后根据不同的环境变量读取不同的文件。rk-boot 使用 REALM，REGION，AZ，DOMAIN 环境变量来区分不同的环境。这也是我们推荐的云原生环境分辨法。比如，REALM="你的业务"，REGION="北京"，AZ="北京一区"，DOMAIN="测试环境"。rk-boot 集成了 viper 来处理配置文件。1.创建配置文件config/beijing.yaml--- region: beijingconfig/shanghai.yaml--- region: shanghaiconfig/default.yaml--- region: default2.创建 boot.yamlboot.yaml 文件告诉 rk-boot 如何启动 Gin 服务。我们使用 config 作为 boot.yaml 中配置文件的入口，可以提供多个 config 文件路径。locale 代表 Config 的环境，我们使用 locale 来区分不同的 Config。为什么 config.name 使用同一个名字？我们希望使用同一套代码，但是读取不同的文件，并且希望文件的名字也不一样。所以通过 locale 来区分不同文件。我们在后面具体介绍 locale 的逻辑。config: # 默认 - name: my-config locale: "*::*::*::*" path: config/default.yaml # 如果环境变量 REGION=beijing，读取此文件 - name: my-config locale: "*::beijing::*::*" path: config/beijing.yaml # 如果环境变量 REGION=shanghai，读取此文件 - name: my-config locale: "*::shanghai::*::*" path: config/shanghai.yaml gin: - name: greeter port: 8080 enabled: true3.创建 main.go设置环境变量：REGION="beijing"，然后读取配置文件，config/beijing.yaml 会被读取。package main import ( "context" "fmt" "github.com/rookie-ninja/rk-boot" "os" ) // Application entrance. func main() { // Set REGION=beijing os.Setenv("REGION", "beijing") // Create a new boot instance. boot := rkboot.NewBoot() // Load config which is config/beijing.yaml fmt.Println(boot.GetConfigEntry("my-config").GetViper().GetString("region")) // Bootstrap boot.Bootstrap(context.Background()) // Wait for shutdown sig boot.WaitForShutdownSig(context.Background()) }4.文件夹结构$ tree . ├── boot.yaml ├── config │ ├── beijing.yaml │ ├── default.yaml │ └── shanghai.yaml ├── go.mod ├── go.sum └── main.go5.验证$ go run main.go我们会得到如下的输出：beijing6.未找到匹配的环境变量如果 REGION="not-matched"，即未找到匹配的环境变量，则会读取默认的配置文件（config/default.yaml）。因为 config/default.yaml 的 locale 属性为 *::*::*::*// Application entrance. func main() { // Set REGION=not-matched os.Setenv("REGION", "not-matched") ... // Load config which is config/beijing.yaml fmt.Println(boot.GetConfigEntry("my-config").GetViper().GetString("region")) ... }default7.环境变量未配置如果我们没有配置 REGION 环境变量，则会读取 config/default.yaml 文件。// Application entrance. func main() { ... // Load config which is config/beijing.yaml fmt.Println(boot.GetConfigEntry("my-config").GetViper().GetString("region")) ... }default概念rk-boot 使用 REALM，REGION，AZ，DOMAIN 四个环境变量来区分配置文件。这四个环境变量可以是任意的值。最佳实践举个例子，我们有一个【云相册】业务。此业务在不同环境里使用的 MySQL 的 IP 地址不一样，则可以这么配置。架构假定，我们的业务在【北京】，【上海】都有服务器，同时为了提高服务可用性，在【北京】和【上海】又各开了2个区。这时候，我们可以机器上配置如下的环境变量，可以通过 Ansible 等工具来批量设置。环境对应环境变量北京，一区，测试REALM="cloud-album"，REGION="bj"，AZ="bj-1"，DOMAIN="test"北京，一区，线上REALM="cloud-album"，REGION="bj"，AZ="bj-1"，DOMAIN="prod"北京，二区，测试REALM="cloud-album"，REGION="bj"，AZ="bj-2"，DOMAIN="test"北京，二区，线上REALM="cloud-album"，REGION="bj"，AZ="bj-2"，DOMAIN="prod"上海，一区，测试REALM="cloud-album"，REGION="sh"，AZ="sh-1"，DOMAIN="test"上海，一区，线上REALM="cloud-album"，REGION="sh"，AZ="sh-1"，DOMAIN="prod"上海，二区，测试REALM="cloud-album"，REGION="sh"，AZ="sh-2"，DOMAIN="test"上海，二区，线上REALM="cloud-album"，REGION="sh"，AZ="sh-2"，DOMAIN="prod"同时，如果我们不使用类似 ETCD，Consul 等服务远程拉取配置文件，可以直接在机器中添加如下文件。每个文件都有不同的 MySQL IP 地址。文件夹结构. ├── boot.yaml ├── config │ ├── bj-1-test.yaml │ ├── bj-1-prod.yaml │ ├── bj-2-test.yaml │ ├── bj-2-prod.yaml │ ├── sh-1-test.yaml │ ├── sh-1-prod.yaml │ ├── sh-2-test.yaml │ ├── sh-2-prod.yaml │ └── default.yaml ├── go.mod ├── go.sum └── main.goboot.yaml接下来，我们在 boot.yaml 里添加如下 config 入口。config: # 默认入口 - name: my-config locale: "*::*::*::*" path: config/default.yaml # 北京，一区，测试环境 - name: my-config locale: "cloud-album::bj::bj-1::test" path: config/bj-1-test.yaml # 北京，一区，线上环境 - name: my-config locale: "cloud-album::bj::bj-1::prod" path: config/bj-1-prod.yaml # 北京，二区，测试环境 - name: my-config locale: "cloud-album::bj::bj-2::test" path: config/bj-2-test.yaml # 北京，二区，线上环境 - name: my-config locale: "cloud-album::bj::bj-2::prod" path: config/bj-2-prod.yaml # 上海，一区，测试环境 - name: my-config locale: "cloud-album::sh::sh-1::test" path: config/sh-1-test.yaml # 上海，一区，线上环境 - name: my-config locale: "cloud-album::sh::sh-1::prod" path: config/sh-1-prod.yaml # 上海，二区，测试环境 - name: my-config locale: "cloud-album::sh::sh-2::test" path: config/sh-2-test.yaml # 上海，二区，线上环境 - name: my-config locale: "cloud-album::sh::sh-2::prod" path: config/sh-2-prod.yaml gin: - name: greeter port: 8080 enabled: truemain.go 中读取配置文件。因为，所有的 Config 都命名为 my-config，在 main.go 中读取的时候，我们可以使用 my-config 获取 ConfigEntry。package main import ( "context" "fmt" "github.com/rookie-ninja/rk-boot" "os" ) // Application entrance. func main() { // Create a new boot instance. boot := rkboot.NewBoot() // Get viper instance based on environment variable boot.GetConfigEntry("my-config").GetViper() // Bootstrap boot.Bootstrap(context.Background()) // Wait for shutdown sig boot.WaitForShutdownSig(context.Background()) }

问题问题来源在MacOS中,默认已经安装好python,版本为2.7python允许同一个系统存在多个python版本在终端使用python命令默认打开的是python2.7,要想使用python3需要使用python3命令,为了直接使用python命令打开python3,就需要设置别名alias问题在bash_profile中配置环境变量后,配置别名alias导致问题:只有在终端执行bash_profile,别名才会生效,每次重启iTerm2后命令就会失效source ~/.bash_profile解决办法将bash_profile中别名alias配置写在zshrc中,这样就解决了iTerm2重启后别名alias失效的问题vi ~/.zshrc原理其实这个原理还是相当于:只有每次重启的时候在终端执行bash_profile:source ~/.ba sh_profile,别名才会生效因为当iTerm2一旦启动,就会自动执行zshrc文件,zshrc中的配置都是全局配置注意!注意使用的shell版本:zsh对应的是zshrcbash对应的是basic在解决别名alias重启终端失效问题的时候,网上的解决办法都是在bashrc中添加配置,我尝试了怎么也没成功后来,突然想到之前使用过的zshrc文件原来是我之前配置oh-my-zsh时把终端shell从bash替换到了zsh,这样使用zshrc后完美解决问题

报错：mysql_config not found$ pip3 install mysqlclient /bin/sh: mysql_config: 未找到命令 ... OSError: mysql_config not found 解决：执行以下命令后再安装mysqlclient$ yum -y install mysql-devel 参考pip3 install mysqlclient 报错 “/bin/sh: 1: mysql_config: not found”的解决方法

ORMObject-Relational Mapping对应关系ORM DB 类 数据表 对象 数据行 属性 字段ORM提高开发效率，降低了执行效率Flask - Sqlalchemy字段类型和参数1、字段类型# 自增长 默认int Auto = models.AutoField(primary_key=True) BigAuto = models.BigAutoField() # 二进制 Binary = models.BinaryField() # 布尔 Boolean = models.BooleanField() NullBoolean = models.NullBooleanField() # 整型 PositiveSmallInteger = models.PositiveSmallIntegerField() # 5字节 SmallInteger = models.SmallIntegerField() # 6字节 PositiveInteger = models.PositiveIntegerField() # 10字节 Integer = models.IntegerField() # 11字节 BigInteger = models.BigIntegerField() # 20字节 # 字符串 Char = models.CharField() # varchar Text = models.TextField() # longtext # 时间日期 Date = models.DateField() DateTime = models.DateTimeField() Duration = models.DurationField() # int python timedelta实现 # 浮点型 Float = models.FloatField() Decimal = models.DecimalField() # 其他 Email = models.EmailField() # 邮箱 Image = models.ImageField() File = models.FileField() FilePath = models.FilePathField() URL = models.URLField() UUID = models.UUIDField() GenericIPAddress = models.GenericIPAddressField()2、关系型字段一对一 OneToOneField多对一 ForeignKey多对对 ManyToManyField 默认或自定义中间表3、字段类型参数默认表名应用_模型类名小写eg: app_student（1）所有字段都有的参数db_column="name" 指定数据库字段名 verbose_name="别名" help_text="表单说明" primary_key=True 设置主键 unique=True 唯一键 null=True 数据库允许为空，默认都是不能为null的 blank=True 前端提交表单允许为空 db_index=True 建立索引 editable=False 不允许编辑字段（2）个别字段的参数CharField max_length=100 最大长度 DateField、DateTime unique_for_date=True 日期必须唯一 unique_for_month=True 月份唯一 auto_now=True 自动更新记录时间 auto_now_add=True 自动增加记录时间 DecimalField max_digits=4 总位数 decimal_places=2 小数点数 eg: 11.22 16.34（3）关系型字段参数OneToOneField related_name="one" 父表查字表数据 ForeignKey on_delete="" 外键所关联的对象被删除时进行的操作 CASCADE： 级联删除。将定义有外键的模型对象同时删除， 默认操作 PROTECT： 阻止删除。会报完整性错误。 DO_NOTHING：什么也不做 SET_NULL：外键设置为 null，前提是 null=True, blank=True。 SET_DEFAULT：设置为外键的默认值，前提是设置了default参数。 SET()：会调用外面的值，可以是一个函数。一般情况下使用 CASCADE 就可以了。 eg: ```python class B(models.Model): foreign = models.ForeignKey(A, on_delete=models.CASCADE) foreign = models.ForeignKey(A, on_delete=models.PROTECT) foreign = models.ForeignKey(A, on_delete=models.DO_NOTHING) foreign = models.ForeignKey(A, on_delete=models.SET_NULL, null=True, blank=True) foreign = models.ForeignKey(A, on_delete=models.SET_DEFAULT, default=0) foreign = models.ForeignKey(A, on_delete=models.SET) 4、自关联示例：地址 省-市-县 级联 class AddressInfo(models.Model): address = models.CharField(max_length=200, null=True, blank=True, verbose_name="地址") pid = models.ForeignKey("self", null=True, blank=True, verbose_name="自关联", on_delete=models.SET_NULL) def __str__(self): return self.address元数据Meta修改应用名称apps.pyclass OrmdemoConfig(AppConfig): name = 'ormdemo' verbose_name = "应用名称" 修改model元数据 class AddressInfo(models.Model): address = models.CharField(max_length=200, null=True, blank=True, verbose_name="地址") note = models.CharField(max_length=200, null=True, blank=True, verbose_name="说明") pid = models.ForeignKey("self", null=True, blank=True, verbose_name="自关联", on_delete=models.SET_NULL) def __str__(self): return self.address class Meta: db_table = "address" # 自定义表名 ordering = ["pid_id"] # 指定排序字段 verbose_name = "地址" # 单数 verbose_name_plural = verbose_name # 复数 abstract = True # 设置为基类 permissions = (("定义好的权限", "权限说明"),) managed = False # 按照Django默认方式管理数据表 unique_together = ("address", "note") # 联合唯一键，单元组或多元组 app_label = "ormdemo" # 定义模型类属于哪个应用 db_tablespace = "" # 定义数据库表空间模型类开发实例 """ 讲师 - 助教 一对一 讲师 - 课程表 一对多 课程表 - 学生 多对多 """ class Teacher(models.Model): """讲师信息表""" nickname = models.CharField(max_length=30, primary_key=True, db_index=True, verbose_name="昵称") introduction = models.TextField(default="这位同学很懒，木有签名的说~", verbose_name="简介") fans = models.PositiveIntegerField(default=0, verbose_name="粉丝数") created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间") updated_at = models.DateTimeField(auto_now=True, verbose_name="创建时间") class Meta: verbose_name = "讲师信息表" verbose_name_plural = verbose_name def __str__(self): return self.nickname class Course(models.Model): """课程信息表""" title = models.CharField(max_length=100, primary_key=True, db_index=True, verbose_name="课程名") type = models.CharField(choices=((0, "其他"), (1, "实战课"), (2, "免费课")), max_length=1, default=0, verbose_name="课程类型") price = models.PositiveSmallIntegerField(verbose_name="价格") volume = models.BigIntegerField(verbose_name="销量") online = models.DateField(verbose_name="上线时间") # 删除级联 teacher = models.ForeignKey(Teacher, null=True, blank=True, on_delete=models.CASCADE, verbose_name="讲师") created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间") updated_at = models.DateTimeField(auto_now=True, verbose_name="创建时间") class Meta: verbose_name = "课程信息表" verbose_name_plural = verbose_name def __str__(self): return f"{self.get_type_display()}-{self.title}" class Student(models.Model): """学生信息表""" nickname = models.CharField(max_length=30, primary_key=True, db_index=True, verbose_name="学生姓名") age = models.PositiveSmallIntegerField(verbose_name="年龄") gender = models.CharField(choices=((0, "保密"), (1, "男"), (2, "女")), max_length=1, default=0, verbose_name="性别") study_time = models.PositiveIntegerField(default=0, verbose_name="学习时长(h)") course = models.ManyToManyField(Course, verbose_name="课程") created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间") updated_at = models.DateTimeField(auto_now=True, verbose_name="创建时间") class Meta: verbose_name = "学生信息表" verbose_name_plural = verbose_name def __str__(self): return self.nickname class TeacherAssistant(models.Model): """助教信息表""" nickname = models.CharField(max_length=30, primary_key=True, db_index=True, verbose_name="昵称") hobby = models.CharField(max_length=10, null=True, blank=True, verbose_name="爱好") # 删除置空 teacher = models.OneToOneField(Teacher, null=True, blank=True, on_delete=models.SET_NULL, verbose_name="讲师") created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间") updated_at = models.DateTimeField(auto_now=True, verbose_name="创建时间") class Meta: verbose_name = "助教信息表" verbose_name_plural = verbose_name def __str__(self): return self.nickname 生成数据表python manage.py makemigrations # 生成迁移文件 python manage.py migrate # 执行迁移文件删除某个模型类的完整操作:（1）在已创建的app下, 首先删除models.py中需要删除的模型类（2）删除该模型类在迁移脚本migrations中的对应文件（3）删除该项目在django_migrations中的对应记录（4）删除数据库中对应的数据表导入数据（1）django shell$ python manage.py shellfrom app.models import Mode model = Model() model.name = "name" model.save()（2）脚本导入# -*- coding: utf-8 -*- import os import random from datetime import date import django import sys # 导入项目配置 project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(project_path) os.environ['DJANGO_SETTINGS_MODULE'] = 'mysite.settings' django.setup() from ormdemo.models import Teacher, Course, Student, TeacherAssistant def import_data(): # 讲师数据 create Teacher.objects.create(nickname="Jack", introduction="Python工程师", fans=666) # 课程数据 bulk_create data = [ Course(title=f"Python系列教程{i}", teacher=Teacher.objects.get(nickname="Jack"), type=random.choice([0, 1, 2]), price=random.randint(200, 300), volume=random.randint(100, 10000), online=date(2018, 10, 1) ) for i in range(1, 5) ] Course.objects.bulk_create(data) # 学生数据 update_or_create Student.objects.update_or_create( nickname="A同学", defaults={ "age": random.randint(18, 58), "gender": random.choice([0, 1, 2]), "study_time": random.randint(9, 999) } ) # 正向添加 # 销量大于等于1000的课程 Student.objects.get(nickname="A同学").course.add(*Course.objects.filter(volume__gte=1000)) # 反向添加 # 学习时间大于等于500小时的同学 Course.objects.get(title="Python系列教程1").student_set.add(*Student.objects.filter( study_time__gte=500 )) # 助教数据 get_or_create() TeacherAssistant.objects.get_or_create( nickname="助教1", defaults={ "hobby": "慕课网学习", "teacher": Teacher.objects.get(nickname="Jack") } ) if __name__ == '__main__': import_data() （3）fixturesDjango serialization -> model保存python manage.py dumpdata > data.json # 导出数据python manage.py loaddata data.json # 导入数据（4）mysqldumpMySQL数据库导入导出数据(5)PyCharmPyCharm自带的导入导出工具ModelAPI1、查询，检索，过滤Teacher.objects.all() # 返回多个结果 Teacher.objects.get(id=1) 返回一条结果 Teacher.objects.filter(fans__gte=500) # 返回多个结果2、数据匹配大小写敏感# 双下划线开头`__` Teacher.objects.filter(fans__in=[500, 600]) # i开头表示大小写敏感 Teacher.objects.filter(nickname__icontains="A") 3、结果切片、排序、链式查询Teacher.objects.all()[:1] Teacher.objects.all().order_by("-age") # 负号表示降序 Teacher.objects.filter(fans__gte=500).order_by("nickname") # 查询集可以继续使用排序4、查看执行的原生SQLTeacher.objects.all().order_by("-nickname").query """ SELECT `ormdemo_teacher`.`nickname`, FROM `ormdemo_teacher` ORDER BY `ormdemo_teacher`.`nickname` DESC """返回新的QuerySet的API读操作大部分都返回1、第一类all 全部filter 过滤order_by 排序exclude 排除reverse 逆序 需要在元数据中设置orderingdistinct 去重Student.objects.all().exclude(nickname="A同学") # SELECT `ormdemo_student`.`nickname` # FROM `ormdemo_student` # WHERE NOT (`ormdemo_student`.`nickname` = A同学) Student.objects.all().exclude(nickname="A同学").reverse() """ ELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` WHERE NOT (`ormdemo_student`.`nickname` = A同学) """ 2、第二类extra 别名defer 排除一些字段only 选择一些字段Student.objects.all().extra(select={"name": "nickname"}) """ SELECT (nickname) AS `name`, `ormdemo_student`.`nickname`, `ormdemo_student`.`age` FROM `ormdemo_student` """ Student.objects.all().only("nickname", "age") """ SELECT `ormdemo_student`.`nickname`, `ormdemo_student`.`age` FROM `ormdemo_student` """3、第三类values 获取字典形式values_list 获取元组形式Student.objects.values("nickname", "age") # <QuerySet [{'nickname': 'A同学', 'age': 54}, {'nickname': 'B同学', 'age': 36}]> Student.objects.values_list("nickname", "age") # <QuerySet [('A同学', 54), ('B同学', 36)]> Student.objects.values_list("nickname", flat=True) # 单个字段返回列表 # <QuerySet ['A同学', 'B同学']>4、第四类dates、datatimes根据时间日期获取查询集Student.objects.dates("created_at", "month") """ SELECT DISTINCT CAST(DATE_FORMAT(`ormdemo_student`.`created_at`, '%Y-%m-01') AS DATE) AS `datefield` FROM `ormdemo_student` WHERE `ormdemo_student`.`created_at` IS NOT NULL ORDER BY `datefield` ASC """5、第五类union 并集intersection 交集 需要数据库支持difference 差集 需要数据库支持ret1 = Student.objects.filter(nickname="同学A") ret2 = Student.objects.filter(nickname="同学B") ret1.union(ret2) """ (SELECT `ormdemo_student`.`nickname FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` = '同学A') UNION (SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` = '同学B') LIMIT 26、第六类select_related 一对一，多对一查询优化prefetch_related 一对多，多对多查询优化Course.objects.all().select_related("teacher") """ SELECT `ormdemo_course`.`title`, `ormdemo_teacher`.`nickname` FROM `ormdemo_course` LEFT OUTER JOIN `ormdemo_teacher` ON (`ormdemo_course`.`teacher_id` = `ormdemo_teacher`.`nickname`) LIMIT 21; """ Student.objects.all().prefetch_related("course") """ SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` LIMIT 21; SELECT (`ormdemo_student_course`.`student_id`) AS `_prefetch_related_val_student_id`, `ormdemo_course`.`title` FROM `ormdemo_course` INNER JOIN `ormdemo_student_course` ON (`ormdemo_course`.`title` = `ormdemo_student_course`.`course_id`) WHERE `ormdemo_student_course`.`student_id` IN ('A同学', 'B同学', 'C同学', 'D同学'); """ 反向查询Teacher.objects.get(nickname="Jack").course_set.all() """ SELECT `ormdemo_teacher`.`nickname` FROM `ormdemo_teacher` WHERE `ormdemo_teacher`.`nickname` = 'Jack' SELECT `ormdemo_course`.`title` FROM `ormdemo_course` WHERE `ormdemo_course`.`teacher_id` = 'Jack' LIMIT 21; """7、第七类annotate 聚合计数，求和，平均数，执行原生SQL（分组后的数据进行统计）from django.db.models import Count, Avg, Max, Min, Sum Course.objects.values("teacher").annotate(vol=Sum("volume")) """ SELECT `ormdemo_course`.`teacher_id`, SUM(`ormdemo_course`.`volume`) AS `vol` FROM `ormdemo_course` GROUP BY `ormdemo_course`.`teacher_id` ORDER BY NULL LIMIT 21; """ Course.objects.values("teacher").annotate(pri=Avg("price")) """ SELECT `ormdemo_course`.`teacher_id`, AVG(`ormdemo_course`.`price`) AS `pri` FROM `ormdemo_course` GROUP BY `ormdemo_course`.`teacher_id` ORDER BY NULL LIMIT 21; # order by null用途是强制对查询结果禁用排序 """不返回QuerySet的API写操作都不返回结果集1、获取对象get, get_or_create, first, last, in_bulklatest最近记录, earliest 最早记录 需要设置元数据get_latest_byStudent.objects.get(nickname="A同学") # 返回多个会报错 """ SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` = 'A同学' """ Student.objects.first() """ SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` ORDER BY `ormdemo_student`.`nickname` ASC LIMIT 1 """ Student.objects.last() """ SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` ORDER BY `ormdemo_student`.`nickname` DESC LIMIT 1; """ Student.objects.in_bulk(["A同学"]) """ SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` IN ('A同学'); """ Student.objects.latest() """ SELECT `ormdemo_student`.`nickname FROM `ormdemo_student` ORDER BY `ormdemo_student`.`created_at` DESC LIMIT 1; """ Student.objects.earliest() """ SELECT `ormdemo_student`.`nickname FROM `ormdemo_student` ORDER BY `ormdemo_student`.`created_at` ASC LIMIT 1; 2、创建对象create, bulk_create, update_or_create3、更新对象update, update_or_createStudent.objects.filter(nickname="A同学").update(age=13) """ UPDATE `ormdemo_student` SET `age` = 13 WHERE `ormdemo_student`.`nickname` = 'A同学'; """ 4、删除对象delete 使用filter过滤Student.objects.filter(nickname="A同学").delete() """ SELECT `ormdemo_student`.`nickname FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` = 'A同学'; DELETE FROM `ormdemo_student_course` WHERE `ormdemo_student_course`.`student_id` IN ('A同学'); DELETE FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` IN ('A同学'); (13, {'ormdemo.Student_course': 12, 'ormdemo.Student': 1}) """5、其他操作exists, count, aggregate(整个数据表统计)Student.objects.filter(nickname="B同学").exists() """ SELECT (1) AS `a` FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` = 'B同学' LIMIT 1 """ Student.objects.filter(nickname="B同学").count() """ SELECT COUNT(*) AS `__count` FROM `ormdemo_student` WHERE `ormdemo_student`.`nickname` = 'B同学'; """ Course.objects.aggregate(Max("price"), Min("price"), Avg("price"), Sum("volum")) """ SELECT MAX(`ormdemo_course`.`price`) AS `price__max`, MIN(`ormdemo_course`.`price`) AS `price__min`, AVG(`ormdemo_course`.`price`) AS `price__avg`, SUM(`ormdemo_course`.`volume`) AS `volume__sum` FROM `ormdemo_course`; {'price__max': 295, 'price__min': 210, 'price__avg': 250.75, 'volume__sum': 60559} """自定义聚合查询（略）group_contactF对象和Q对象F对象 操作字段数据Q对象 结合AND OR NOT | ~ & 实现复杂查询from django.db.models import F, Q Student.objects.update(age=F("age") + 3) """ UPDATE `ormdemo_student` SET `age` = (`ormdemo_student`.`age` + 3); """ Student.objects.filter(Q(age__gte=1) & Q(age__lte=10)) """ SELECT `ormdemo_student`.`nickname` FROM `ormdemo_student` WHERE (`ormdemo_student`.`age` >= 1 AND `ormdemo_student`.`age` <= 10) LIMIT 21; """

三大主流框架（1）Django（2）Flask（3）TornadoDjango MVC模式（1）模型 Model（2）视图 View（3）控制器 Controller准备工作1、创建项目django-admin startproject <projectName> # eg: django-admin startproject mysite cd mysite2、项目介绍setting.py # 配置文件 urls.py # 路由配置 manage.py # 管理文件3、Django基本命令python manage.py runserver # 运行Django项目 python manage.py shell # shell环境 python manage.py test # 执行测试4、数据库相关命令python manage.py makemigrations # 创建模型变更的迁移文件 python manage.py migrate # 执行上一个命令创建的迁移文件 python manage.py dumpdata # 数据库导出到文件 python manage.py loaddata # 文件导入到数据库5、Django项目 Vs Django应用每个应用可以管理自己的模型视图模板路由和静态文件一个项目可以包含一组配置和若干个Django应用6、创建应用（1）新建应用python manage.py startapp <appName> # eg: python manage.py startapp myblog（2）setting.py 中注册appINSTALLED_APPS = [ # ... 'myblog.apps.MyblogConfig' # 这是新建的app ]（3）新建视图函数myblog/views.pyfrom django.http import HttpResponse def hello(request): return HttpResponse("hello Django") （4）app中配置url新建 myblog/urls.py 将url与视图做映射关系 from django.urls import path from . import views urlpatterns = [ path('hello', views.hello), ] （5）项目中配置urlurls.pyfrom django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('myblog/', include("myblog.urls")), ]访问测试 http://127.0.0.1:8000/myblog/hello7、应用目录views.py # 视图处理 models.py # 应用模型 admin.py # Admin模块管理对象 apps.py # 声明应用 tests.py # 编写应用测试用例 urls.py # 管理应用路由（自行创建）Django模型层视图层 <-> 模型层 <-> 数据库1、模型层（1）屏蔽不同数据库之间的差异（2）便捷工据2、settings.py 配置数据库引擎DATABASES # 选项配置数据库 默认为sqlite33、模型字段类型（1）数字类型：IntegerField（2）文本类型：TextField（3）日期类型：DataTimeField（4）自增ID： AutoField（5）主键： primary_keymyblog/models.py 新建文章modelfrom django.db import models class Article(models.Model): # 文章的唯一ID article_id = models.AutoField(primary_key=True) # 文章标题 title = models.TextField() # 文章摘要 brief_content = models.TextField() # 文章内容 content = models.TextField() # 文章发布日期 publish_date = models.DateTimeField(auto_now=True) 执行数据库建表操作$ python manage.py makemigrations # 生成建表操作 $ python manage.py migrate # 执行操作 4、Django Shell交互式编程小范围测试进入shellpython manage.py shell from myblog.models import Article # 新建文章 a = Article() a.title = "文章标题" a.brief_content = "文章摘要" a.content = "文章内容" print(a) a.save() # 查询文章 articles = Article.objects.all() article = articles[0] print(article.title) 5、Django Admin后台管理工具用户认证，显示管理表格，校验输入等相似功能创建管理员用户python manage.py createsuperuser后台管理地址http://127.0.0.1:8000/admin将模型注册到admin模块myblog/admin.pyfrom django.contrib import admin # Register your models here. from .models import Article admin.site.register(Article) 修改后台显示myblog/models.pyclass Article(models.Model): # ... # 修改admin后台显示 Article object -> self.title def __str__(self): return self.title 6、数据返回编写视图函数myblog/views.py from django.http import HttpResponse, JsonResponse from .models import Article def articles(request): # 查询数据 select * from article lst = Article.objects.values().all() return JsonResponse(list(lst), safe=False) 配置app路由myblog/urls.pyfrom django.urls import path from . import views urlpatterns = [ path('hello', views.hello), # 新增路由映射 path('articles', views.articles), ]测试返回http://127.0.0.1:8000/myblog/articles[ { "article_id": 1, "title": "文章标题", "brief_content": "文章摘要", "content": "文章内容", "publish_date": "2019-09-14T14:36:32.400Z" }, { "article_id": 2, "title": "这个事第二篇文章", "brief_content": "这个事第二篇文章的内容摘要", "content": "这个事第二篇文章的内容", "publish_date": "2019-09-14T14:36:51.387Z" } ]Django视图与模板Bootstrap栅格系统，宽为12等份https://www.bootcss.com/1、模板系统表现形式是文本分离文档的表现形式和表现内容定义了特有的标签占位符2、基本语法（1）变量{{name}}（2）for循环{% for item in list %} <li>{{item}}</li> {% endfor %}（3）if-else分支{% if true %} <p>true</p> {% else %} <p>false</p> {% endif %}3、渲染页面myblog/views.pyfrom django.shortcuts import render from .models import Article def index_page(request): lst = Article.objects.all() data = { "article_list": lst } return render(request, "myblog/index.html", data) myblog/templates/myblog/index.html{% for article in article_list %} <div class="page-body-main"> <h2>{{ article.title }}</h2> <p>{{ article.content }}</p> </div> {% endfor %}4、路由参数myblog/urls.pyfrom django.urls import path from . import views # 添加命名空间 app_name = "myblog" urlpatterns = [ #... path('detail/<int:article_id>', views.detail_page, name="detail"), ] 传递路由参数myblog/templates/myblog/index.html<!-- 硬编码 --> <a href="/myblog/detail/{{article.article_id}}">{{ article.title }} <!-- 或者使用name --> <a href="{% url 'myblog:detail' article.article_id %}">{{ article.title }}5、查询SQL日志setting.py# 查看sql日志 LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level': 'DEBUG', }, } }6、Paginator分页视图函数 myblog/views.py def index_page(request): page = request.GET.get("page", "1") page = int(page) # 并没有直接查询所有数据 lst = Article.objects.all() # 分页,每页5个 paginator = Paginator(lst, 5) current_article_list = paginator.get_page(page) # 上一页下一页 if current_article_list.has_next(): next_page = current_article_list.next_page_number() else: next_page = page if current_article_list.has_previous(): previous_page = current_article_list.previous_page_number() else: previous_page = page data = { "article_list": current_article_list, "page_range": paginator.page_range, "current_page": page, "previous_page": previous_page, "next_page": next_page, } return render(request, "myblog/index.html", data) 模板渲染分页部分（使用Bootstrap样式）myblog/templates/myblog/index.html <ul class="pagination"> <li> <a href="{% url 'myblog:index' %}?page={{ previous_page }}" aria-label="Previous"> <span aria-hidden="true">«</span> </a> </li> {% for page in page_range %} <li><a href="{% url 'myblog:index' %}?page={{ page }}">{{ page }}</a></li> {% endfor %} <li> <a href="{% url 'myblog:index' %}?page={{ next_page }}" aria-label="Next"> <span aria-hidden="true">»</span> </a> </li> </ul>