turkeyzhou

jBPM-jPDL学习笔记——流程设计与控制

背景
本片文章，我们将从业务流程的设计开始，通过带领大家完成一个完整工作流的程序设计，来学习jPDL的使用。

业务流程设计
这里我们实现一个相对简化的公司借款申请流程。流程图如下：

在jPDL中，与流程设计相关的文件有三个：processdefinition.xml、gdp.xml、processimage.jpg。其中processdefinition.xml是流程定义的描述文件；gpd.xml是对图形界面呈现的XML描述；而 processimage.jpg则是对图形界面的快照。下面我们将展示本样例的流程定义文件。

流程定义描述

processdefinition.xml文件

引用

<?xml version="1.0" encoding="UTF-8"?>

<process-definition   xmlns ="urn:jbpm.org:jpdl-3.2" name="simple">
   <start-state name="开始">
      <transition name="借款发起" to="填写借款申请">
<action name="Action_StartProcess" class="com.firstflow.action.StartProcessActionHander"></action>
</transition>
   </start-state>
   <task-node name="填写借款申请">
<task name="Task_AssignToInitiator">
<assignment class="com.firstflow.task.NewApplicationAssignmentHandler"></assignment>
</task>
<transition to="部门经理审批" name="提交申请">
<action name="Action_SubmitApply" class="com.firstflow.action.SubmitApplyActionHandler"></action>
</transition>
</task-node>

<task-node name="部门经理审批">
<task name="Task_ManagerApprove">
<assignment class="com.firstflow.task.DepartmentManagerApproveAssignmentHandler"></assignment>
</task>
<transition to="金额判定" name="部门经理审批通过">
<action name="Task_ManagerApproved" class="com.firstflow.action.ManagerApprovedActionHandler"></action>
</transition>
<transition to="结束" name="部门经理驳回">
<action name="Action_ManagerDisapprove" class="com.firstflow.action.ManagerDisapproveActionHandler"></action>
</transition>
</task-node>

<node name="财务拨款">
<action name="Action_AccountantProcess" class="com.firstflow.action.AccountantProcessActoinHandler"></action>
<transition to="结束" name="邮件通知">
<action name="Action_Mail" class="com.firstflow.action.SendMailActionHandler"></action>
</transition>
</node>

<decision name="金额判定">
<handler class="com.firstflow.decision.MoneyCheckDecisionHandler"></handler>
<transition to="总经理审批" name=">5000元总经理审批"></transition>
<transition to="财务拨款" name="<5000元财务拨款"></transition>
</decision>

<task-node name="总经理审批">
<task name="Task_PresidentApprove">
<assignment class="com.firstflow.task.PresidentApproveAssignmentHandler"></assignment>
</task>
<transition to="财务拨款" name="总经理审批通过">
<action name="Action_PresidentApproved" class="com.firstflow.action.PresidentApprovedActionHandler"></action>
</transition>
<transition to="结束" name="总经理驳回">
<action name="Action_PresidentDisapproved" class="com.firstflow.action.PresidentDisapprovedActionHandler"></action>
</transition>
</task-node>
   <end-state name="结束"></end-state>
</process-definition>

在样例流程中，除了开始和结束结点外，我们定义了三种类型的结点：

任务结点<task-node>
任务结点是一个需要人工参与的结点类型。当流程进入结点时，会生成相应的任务实例(TaskInstatnce)，并通过委派接口 AssignmentHandler或jBPM表达式将任务委派给一个或多个特定的角色或参与者。结点自身进入等待状态，直到任务被参与者完成或者跳过，流程继续。

判定结点<decision>
判定结点的设计目标是根据上下文环境和程序逻辑，判定流程转向。通过指定一个实现DecisionHandlder接口的Java委派类或jBPM表达式，来返回转向（transition）的字符窜类型的名称（可以是中文哦），来达到决定流程方向的功能。

普通结点<node>
普通结点也可以定义相应的处理任务，通过定义相应的ActioinHandler类。同任务结点不同的是，普通结点定义的任务是由流程自动执行的，无须人工干预。

三种结点都可定义结点事件（event）：
node-enter，该事件在流程进入结点时触发
node-leave，该事件在流程离开节点是触发
可以在事件上挂接ActioinHandler接口的实现类来完成一些特定的功能。

三种节点都可以定义异步处理方式（async属性）：
异步处理意味着每个结点的事务处理是通过消息机制分离的，不再同一线程中统一调用执行。而是由消息监听线程从消息队列中取得消息体来运行相应得程序。
此外我们定义了结点间的转向（transition），用来记录和处理状态的变迁。每个转向中，可以委派一个或多个的ActioinHandler接口实现类，负责处理节点变迁时的上下文状态变更及回调用户定义的处理程序。

流程的程序接口说明

动作处理接口（ActioinHandler）
接口方法：void execute( ExecutionContext executionContext ) throws Exception
该接口是jPDL中最常用的一个回调接口。从它的接口方法可以发现，它仅仅暴露了流程执行上下文变量ExecutionContext。用户程序通过ExecutionContext来了解流程的执行状态，并通过改变ExecutionContext中的属性值来影响流程的执行。
ActioinHandler接口可以在所有能包含事件(event)、动作(action)元素的地方被回调。

判定处理接口（DecisionHandlder）
接口方法：String decide(ExecutionContext executionContext) throws Exception
判定接口仅适用于判定节点(decision)中。从它的接口方法可以看出，方法要返回一个字符串型的结果，这个结果必须和判定节点拥有的转向(transition)集合中的一条转向名称相匹配。
在DecisionHandlder的接口方法中一样能访问到ExecutionContext变量，这为判定提供了执行上下文的根据。当然，如果有必要，用户也可以在该接口中改变ExecutionContext中的变量值。

委派处理接口（AssignmentHandler）
接口方法：void assign(Assignable assignable, ExecutionContext executionContext) throws Exception;
委派处理接口被用户任务元素(task)的委派(assignment)子元素中，它的职责很明确，就是将任务分配给指定的人员或角色。
在AssignmentHandler接口的方法中，Assignable变量通常指任务实例(TaskInstance)。通过将 ExecutionContext和TaskInstance两个变量都暴露给接口方法，用户就可以根据流程上下文情况，来决定要将指定的任务分配个谁。

流程的部署

用户使用jPDL的流程设计器定义业务流程，当然，你也可以直接用文档编辑器直接编辑processdefinition.xml定义文件。定义文档是可以直接被ProcessDefinition类载入使用的，但在正式运行的系统中，流程定义信息更多是使用关系型数据库来存储。从流程定义文件将数据导入流程数据库的过程，我们称之为流程部署。
jPDL的流程部署文件包含processdefinition.xml的定义部分和Java处理器的代码部分，这些文件可以被一起打包成.jpdl的zip格式包而后上传服务器端。这个过程可以在流程设计器界面的“deployment”标签页中操作：

这里我们着重要讲述的是接受部署文件上载的服务器端配置。在jBPM3.2的包中带着一个jPDL的管理控制台web应用，默认名字为jbpm- console。该应用带有接受流程定义包部署的程序，但不是最小化的。实际上完成流程部署功能的，只是jbpm-jpdl.jar核心包中的一个 servlet类：org.jbpm.web.ProcessUploadServlet . 完成这个Servlet的成功部署，需要以下工作：

1. 配置web.xml，将servlet配置成启动时加载，如下：

引用

<web-app>
<servlet>
<servlet-name>GDP Deployer Servlet</servlet-name>
<servlet-class>org.jbpm.web.ProcessUploadServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>GDP Deployer Servlet</servlet-name>
<url-pattern>/upload/*</url-pattern>
</servlet-mapping>

</web-app>

2. 建立流程定义存储数据库表：
Demo中，我们使用的数据库是MySQL的，在E:/Java/tools/jbpm-jpdl-3.2.2/db/目录下有个 jbpm.jpdl.mysql.sql数据库脚本文件。但我们不能直接导入该文件, 会提示有错误, 应为该文件的SQL语句末尾少了分号，在批量执行时，MySQL报错。需要在每一行SQL的末尾添加一个分号，这样就可以用source命令导入了。

3. 配置Hibernate.cfg.xml
由于jBPM的数据库持久化是依靠Hibernate进行的，因此需要配置Hibernate.cfg.xml使其适应我们的MySQL环境

引用

<property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/linly</property>
    <property name="hibernate.connection.username">linly</property>
    <property name="hibernate.connection.password">coffee</property>
    <property name="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</property>

4. Import需要的jar包
这里的jar包包括三部分：jbpm的核心包；Hibernate及其支撑包；MySQL的JDBC驱动包。

到此，我们的配置工作完成，这是实现jBPM流程部署服务端的最小化应用配置。

流程控制及API使用

样例程序中的Handler接口实现

下面，根据上述的接口分类，列出样例程序中的类名及相应的功能说明，具体可参考源代码。
动作处理接口（ActioinHandler）

这里要提到一个很重要的区别，就是作用于Node上的ActoinHandler和作用于Transition上的ActoinHandler是有不同的。区别在于，Node上的ActoinHandler在结束业务逻辑处理后，必须调用 executionContext.leaveNode();或executionContext.leaveNode(transition)来保证流程向下执行；而作用于Transition上的则不需要。

判定处理接口（DecisionHandlder）

委派处理接口（AssignmentHandler）

流程测试剖析

本章节，我们将给大家剖析两个流程测试类。一个是简单的基于内存模型的流程测试FirstFlowProcessTest；一个是更贴近实用的，基于MySQL数据库操作的标准测试案例。通过对这两个测试例程的分析，来直观的学习如何通过Java API操作jPDL。

简单流程测试案例
测试案例类：FirstFlowProcessTest.java

Java代码

public class FirstFlowProcessTest extends TestCase {
ProcessDefinition pdf ;
ProcessInstance pi;
public void test4000YuanApplication() throws Exception {
deployProcessDefinition();
createProcessInstance("linly");
submitApplication(4000);
approveByManager(true);
checkTasks();
}
public void test6000YuanApplication() throws Exception {
deployProcessDefinition();
createProcessInstance("linly");
submitApplication(6000);
approveByManager(true);
approveByPresident(true);
checkTasks();
}
public void test7000YuanApplication() throws Exception {
deployProcessDefinition();
createProcessInstance("linly");
submitApplication(7000);
approveByManager(true);
approveByPresident(false);
checkTasks();
}
/**
* 部署流程定义
* @throws Exception
*/
protected void deployProcessDefinition() throws Exception{
System.out.println("==FirstFlowProcessTest.deployProcessDefinition()==");
pdf = ProcessDefinition.parseXmlResource("firstflow/processdefinition.xml");
assertNotNull("Definition should not be null", pdf);
}
/**
* 生成流程实例
*/
protected void createProcessInstance(String user){
System.out.println("==FirstFlowProcessTest.createProcessInstance()==");
assertNotNull("Definition should not be null", pdf);
//生成实例
pi = pdf.createProcessInstance();
assertNotNull("processInstance should not be null", pi);
//设置流程发起人
pi.getContextInstance().createVariable("initiator", user);
//触发流程转向
pi.signal();
}
/**
* 填写提交申请单
* @param money
*/
protected void submitApplication(int money){
System.out.println("==FirstFlowProcessTest.submitApplication()==");
TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next() ;
System.out.println("ti.actor = " + ti.getActorId());
ContextInstance ci = ti.getContextInstance();
ci.setVariable("money",new Integer(money));
ti.end();
}
/**
* 部门经理审批
* @param pass
*/
@SuppressWarnings("unchecked")
protected void approveByManager(boolean pass){
System.out.println("==FirstFlowProcessTest.approveByManager()==");
Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
for( ;it.hasNext(); ){
TaskInstance ti = it.next();
if(ti.getActorId().equals("DepartmentManager")){
List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
for(Transition t : transitions){
System.out.println("----Transition" + t.getName());
}
assertEquals("DepartmentManager",ti.getActorId());
if(pass){
ti.end("部门经理审批通过");
}else{
ti.end("部门经理驳回");
}
return;
}
}
}
/**
* 总经理审批
* @param pass
*/
@SuppressWarnings("unchecked")
protected void approveByPresident(boolean pass){
System.out.println("==FirstFlowProcessTest.approveByPresident()==");
Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
for( ;it.hasNext(); ){
TaskInstance ti = it.next();
if(ti.getActorId().equals("President")){
List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
for(Transition t : transitions){
System.out.println("----Transition" + t.getName());
}
assertEquals("President",ti.getActorId());
if(pass){
ti.end("总经理审批通过");
}else{
ti.end("总经理驳回");
}
return;
}
}
}
/**
* 打印任务记录
*/
@SuppressWarnings("unchecked")
protected void checkTasks(){
System.out.println("==FirstFlowProcessTest.checkTasks()==");
Collection<TaskInstance> coll = pi.getTaskMgmtInstance().getTaskInstances();
System.out.println("====Process has task:====");
for(TaskInstance ti : coll){
System.out.println("=="+ti.getName()+"==");
System.out.println("=="+ti.getActorId()+"==");
System.out.println("=="+ti.getVariables().toString() +"==");
}
System.out.println("====end====");
}

public class FirstFlowProcessTest extends TestCase {
	ProcessDefinition pdf ;
    ProcessInstance pi;       

	public void test4000YuanApplication() throws Exception {
		deployProcessDefinition();
		createProcessInstance("linly");
		submitApplication(4000);
		approveByManager(true);
		checkTasks();
	}

	public void test6000YuanApplication() throws Exception {
		deployProcessDefinition();
		createProcessInstance("linly");
		submitApplication(6000);
		approveByManager(true);
		approveByPresident(true);
		checkTasks();
	}
	
	public void test7000YuanApplication() throws Exception {
		deployProcessDefinition();
		createProcessInstance("linly");
		submitApplication(7000);
		approveByManager(true);
		approveByPresident(false);
		checkTasks();
	}
	
	/**
	 * 部署流程定义
	 * @throws Exception
	 */
    protected void deployProcessDefinition() throws Exception{
        System.out.println("==FirstFlowProcessTest.deployProcessDefinition()==");
        pdf = ProcessDefinition.parseXmlResource("firstflow/processdefinition.xml");
        assertNotNull("Definition should not be null", pdf);        
    }    
    /**
     * 生成流程实例 
     */
    protected void createProcessInstance(String user){
        System.out.println("==FirstFlowProcessTest.createProcessInstance()==");
    assertNotNull("Definition should not be null", pdf);
        //生成实例
    	pi = pdf.createProcessInstance();
    	assertNotNull("processInstance should not be null", pi);
    	//设置流程发起人
    	pi.getContextInstance().createVariable("initiator", user);
    	//触发流程转向
    	pi.signal();
    }    
    /**
     * 填写提交申请单
     * @param money
     */
    protected void submitApplication(int money){    	
        System.out.println("==FirstFlowProcessTest.submitApplication()==");        
        TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next() ;        
        System.out.println("ti.actor = " + ti.getActorId());        
        ContextInstance ci = ti.getContextInstance();
        ci.setVariable("money",new Integer(money));
        ti.end();    	
    }    
    /**
     * 部门经理审批
     * @param pass
     */    
    @SuppressWarnings("unchecked")
    protected void approveByManager(boolean pass){    	
        System.out.println("==FirstFlowProcessTest.approveByManager()==");        
        Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();        
        for( ;it.hasNext(); ){        	
        	TaskInstance ti = it.next();        	
        	if(ti.getActorId().equals("DepartmentManager")){
                List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
                for(Transition t : transitions){
                	System.out.println("----Transition" + t.getName());
                }
                assertEquals("DepartmentManager",ti.getActorId());
                if(pass){
                	 ti.end("部门经理审批通过");    	
                }else{
                	ti.end("部门经理驳回");
                }
                return;
        	}
        }        
    }
    
    /**
     * 总经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByPresident(boolean pass){
    	   System.out.println("==FirstFlowProcessTest.approveByPresident()==");
    	   
           Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
           
           for( ;it.hasNext(); ){
           	
	           	TaskInstance ti = it.next();
	           	
	           	if(ti.getActorId().equals("President")){
	                List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
	                for(Transition t : transitions){
	                	System.out.println("----Transition" + t.getName());
	                }
	                assertEquals("President",ti.getActorId());
	                if(pass){
	                	 ti.end("总经理审批通过");    	
	                }else{
	                	ti.end("总经理驳回");
	                }
	                return;
	           	}
           }
    }    
    /**
     * 打印任务记录
     */
    @SuppressWarnings("unchecked")
    protected void checkTasks(){       
        System.out.println("==FirstFlowProcessTest.checkTasks()==");
        Collection<TaskInstance> coll = pi.getTaskMgmtInstance().getTaskInstances();
        System.out.println("====Process has task:====");
        for(TaskInstance ti : coll){
               System.out.println("=="+ti.getName()+"==");
               System.out.println("=="+ti.getActorId()+"==");
               System.out.println("=="+ti.getVariables().toString() +"==");
        }
        System.out.println("====end====");   
    }

该案例是在没有数据库支持的情况下，对报销流程进行运行测试，测试逻辑如下：

1. 加载流程定义

Java代码

ProcessDefinition.parseXmlResource("firstflow/processdefinition.xml")

ProcessDefinition.parseXmlResource("firstflow/processdefinition.xml")

代码说明：
在没有数据库存储的情况下，流程定义通过ProcessDefinition类直接从processdefinition.xml文件中解析加载。

2. 实例化流程对象

Java代码

//生成实例
pi = pdf.createProcessInstance();
assertNotNull("processInstance should not be null", pi);
//设置流程发起人
pi.getContextInstance().createVariable("initiator", user);
//触发流程转向
pi.signal();

      //生成实例
       pi = pdf.createProcessInstance();
      assertNotNull("processInstance should not be null", pi);
      //设置流程发起人
       pi.getContextInstance().createVariable("initiator", user);
      //触发流程转向
       pi.signal();

代码说明：
在获得流程定义的实例后，可以用它生成流程实例，使用如下的语句：
pi = pdf.createProcessInstance();
流程实例拥有自己的ContextInstance环境变量对象。它实际上是一个HashMap，以key-value方式记录了流程的上下文变量值，代码中的
pi.getContextInstance().createVariable("initiator", user);就是向环境变量中添加一个key为initiator的对象。
每个流程实例都拥有自己Token令牌对象，主流程有自己的RootToken，子流程也拥有自己的子Token。父流程的Token和子流程的Token相互关联，形成Token树。
Token对象表示流程运行的当前位置（运行到哪个节点了）。通过对Token对象的signal()方法调用，可以使流程向下运行。代码中的 pi.signal();实际上是间接调用了pi.getRootToken().signal();它使得新建的流程继续向下个节点（即借款申请单填写）进发。

3. 员工发起借款申请

Java代码

/**
* 填写提交申请单
* @param money
*/
protected void submitApplication(int money){
System.out.println("==FirstFlowProcessTest.submitApplication()==");
TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next()
System.out.println("ti.actor = " + ti.getActorId());
ContextInstance ci = ti.getContextInstance();
ci.setVariable("money",new Integer(money));
ti.end();

    /**
     * 填写提交申请单
     * @param money
     */
    protected void submitApplication(int money){
    		 System.out.println("==FirstFlowProcessTest.submitApplication()==");
        
        TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next()         
        System.out.println("ti.actor = " + ti.getActorId());
        ContextInstance ci = ti.getContextInstance();
        ci.setVariable("money",new Integer(money));
        ti.end();
}

代码说明：
在借款流程发起后，流程进入了申请单填写阶段。这个阶段是个人工的任务，需要用户的介入。因此，对于要借款的用户而言，首先是获取填写申请单的任务实例：
TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next()
在这个测试类中，由于没有数据库。对流程实例的引用是依靠了类的全局标量pi。这里通过pi获取全部的任务列表。实际上有且仅有一个任务，就是我们刚刚发起的申请单填写任务。
接下来，我们获取流程的上下文变量，将申请借款的数额记录在上下文变量中ContextInstance ci = ti.getContextInstance();
ci.setVariable("money",new Integer(money));
最后，我们要结束当前任务，告诉流程继续下行，调用ti.end()；这个方法的本质依然是调用了token.signal()，它选择了一个默认的transition进行转向。这里要说明的是signal方法有多态的实现signal(Transition transition)，是可以指定具体转向参数的。

4. 部门领导审批申请

Java代码

/**
* 部门经理审批
* @param pass
*/
@SuppressWarnings("unchecked")
protected void approveByManager(boolean pass){
System.out.println("==FirstFlowProcessTest.approveByManager()==");
Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
for( ;it.hasNext(); ){
TaskInstance ti = it.next();
if(ti.getActorId().equals("DepartmentManager")){
List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
for(Transition t : transitions){
System.out.println("----Transition" + t.getName());
}
assertEquals("DepartmentManager",ti.getActorId());
if(pass){
ti.end("部门经理审批通过");
}else{
ti.end("部门经理驳回");
}
return;
}
}
}

     /**
     * 部门经理审批
     * @param pass
     */    
    @SuppressWarnings("unchecked")
    protected void approveByManager(boolean pass){    	
        System.out.println("==FirstFlowProcessTest.approveByManager()==");        
        Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();        
        for( ;it.hasNext(); ){        	
        	TaskInstance ti = it.next();        	
        	if(ti.getActorId().equals("DepartmentManager")){
                List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
                for(Transition t : transitions){
                	System.out.println("----Transition" + t.getName());
                }
                assertEquals("DepartmentManager",ti.getActorId());
                if(pass){
                	 ti.end("部门经理审批通过");    	
                }else{
                	ti.end("部门经理驳回");
                }
                return;
        	}
        } 
}

代码说明：
这里，流程进入了部门经理审批阶段。由于没有数据库支持，我们只能采取遍历任务列表，并比对委派者ID的方式来确定委派给部门经理的任务实例。（在后面的基于数据库的标准案例中，我们会看到如果根据用户的ID来获取分配给指定用户的任务）
ti.getActorId().equals("DepartmentManager") // 比对任务的委派人。
ti.getToken().getNode().getLeavingTransitions();//获取任务在当前节点上的所有转向。
这里我们要特别指出的是ti.end("部门经理审批通过")和ti.end("部门经理驳回")这实际上调用token.signal(transition);来完成任务的转向，从而使流程继续。

5. 总经理审批申请

Java代码

/**
* 总经理审批
* @param pass
*/
@SuppressWarnings("unchecked")
protected void approveByPresident(boolean pass){
System.out.println("==FirstFlowProcessTest.approveByPresident()==");
Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
for( ;it.hasNext(); ){
TaskInstance ti = it.next();
if(ti.getActorId().equals("President")){
List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
for(Transition t : transitions){
System.out.println("----Transition" + t.getName());
}
assertEquals("President",ti.getActorId());
if(pass){
ti.end("总经理审批通过");
}else{
ti.end("总经理驳回");
}
return;
}
}
}

     /**
     * 总经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByPresident(boolean pass){
    	   System.out.println("==FirstFlowProcessTest.approveByPresident()=="); 
           Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
           
           for( ;it.hasNext(); ){           	
	           	TaskInstance ti = it.next();	           	
	           	if(ti.getActorId().equals("President")){
	                List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
	                for(Transition t : transitions){
	                	System.out.println("----Transition" + t.getName());
	                }
	                assertEquals("President",ti.getActorId());
	                if(pass){
	                	 ti.end("总经理审批通过");    	
	                }else{
	                	ti.end("总经理驳回");
	                }
	                return;
	           	}
           }
}

代码说明：
此步代码同“部门经理审批”代码相似，不作更多说明。

标准流程测试案例

该案例模拟了标准运行环境中，基于关系型数据库的jBPM系统是如何执行流程的。
测试案例类：FirstFlowProcessDBTest.java

Java代码

public class FirstFlowProcessDBTest {
/*
* 初始化jBPM配置
* 包含对Hibernate的数据库初始化
*/
static JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
public static void main(String[] args){
FirstFlowProcessDBTest test = new FirstFlowProcessDBTest();
test.test4000YuanApplication();
test.test6000YuanApplication();
test.test7000YuanApplication();
}
public void test4000YuanApplication(){
ProcessInstance pi = createProcessInstance("linly");
submitApplication("linly" , 4000);
approveByManager(true);
checkTasks(pi);
}
public void test6000YuanApplication() {
ProcessInstance pi = createProcessInstance("linly");
submitApplication("linly" , 6000);
approveByManager(true);
approveByPresident(true);
checkTasks(pi);
}
public void test7000YuanApplication() {
ProcessInstance pi = createProcessInstance("linly");
submitApplication("linly" , 7000);
approveByManager(true);
approveByPresident(false);
checkTasks(pi);
}
/**
* 生成流程实例
*/
protected ProcessInstance createProcessInstance(String user){
System.out.println("==FirstFlowProcessTest.createProcessInstance()==");
JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try {
GraphSession graphSession = jbpmContext.getGraphSession();
/*
* 从数据库获取指定的流程定义
*/
ProcessDefinition pdf = graphSession.findLatestProcessDefinition("simple");
//生成流程实例
ProcessInstance pi = pdf.createProcessInstance();
//设置流程发起人
pi.getContextInstance().createVariable("initiator", user);
//触发流程转向
pi.signal();
/*
* 保存流程实例
*/
jbpmContext.save(pi);
return pi;
}finally{
jbpmContext.close();
}
}
/**
* 填写提交申请单
* @param money
*/
@SuppressWarnings("unchecked")
protected void submitApplication(String actorId , int money){
System.out.println("==FirstFlowProcessTest.submitApplication()==");
JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try {
/*
*根据操作者ID，获取属于该操作者的任务集
*/
List<TaskInstance> taskInstances = jbpmContext.getTaskList(actorId);
for(TaskInstance ti : taskInstances){
System.out.println("ti.name = " + ti.getName());
System.out.println("ti.actor = " + ti.getActorId());
ContextInstance ci = ti.getContextInstance();
ci.setVariable("money",new Integer(money));
ti.end();
}
}finally{
jbpmContext.close();
}
}
/**
* 部门经理审批
* @param pass
*/
@SuppressWarnings("unchecked")
protected void approveByManager(boolean pass){
System.out.println("==FirstFlowProcessTest.approveByManager()==");
JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try{
List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");
for(TaskInstance ti : taskInstances){
System.out.println("ti.name = " + ti.getName());
System.out.println("ti.actor = " + ti.getActorId());
if(pass){
ti.end("部门经理审批通过");
}else{
ti.end("部门经理驳回");
}
}
}finally{
jbpmContext.close();
}
}
/**
* 总经理审批
* @param pass
*/
@SuppressWarnings("unchecked")
protected void approveByPresident(boolean pass){
System.out.println("==FirstFlowProcessTest.approveByPresident()==");
JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try{
List<TaskInstance> taskInstances = jbpmContext.getTaskList("President");
for(TaskInstance ti : taskInstances){
System.out.println("ti.name = " + ti.getName());
System.out.println("ti.actor = " + ti.getActorId());
if(pass){
ti.end("总经理审批通过");
}else{
ti.end("总经理驳回");
}
}
}finally{
jbpmContext.close();
}
}
/**
* 打印任务记录
*/
@SuppressWarnings("unchecked")
protected void checkTasks(ProcessInstance pi){
System.out.println("==FirstFlowProcessTest.checkTasks()==");
JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try{
List<TaskInstance> coll = jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance(pi);
System.out.println("====Process has task:====");
for(TaskInstance ti : coll){
System.out.println("=="+ti.getName()+"==");
System.out.println("=="+ti.getActorId()+"==");
System.out.println("=="+ti.getVariables().toString() +"==");
}
System.out.println("====end====");
}finally{
jbpmContext.close();
}
}
}

public class FirstFlowProcessDBTest {	
	/*
	 * 初始化jBPM配置
	 * 包含对Hibernate的数据库初始化
	 */
    static JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();    
    public static void main(String[] args){
    	FirstFlowProcessDBTest test = new FirstFlowProcessDBTest();
    	test.test4000YuanApplication();
    	test.test6000YuanApplication();
    	test.test7000YuanApplication();
    }
    
	public void test4000YuanApplication(){
		ProcessInstance pi = createProcessInstance("linly");
		submitApplication("linly" , 4000);
		approveByManager(true);
		checkTasks(pi);
	}
	public void test6000YuanApplication() {
		ProcessInstance pi = createProcessInstance("linly");
		submitApplication("linly" , 6000);
		approveByManager(true);
		approveByPresident(true);
		checkTasks(pi);
	}	
	public void test7000YuanApplication() {
		ProcessInstance pi = createProcessInstance("linly");
		submitApplication("linly" , 7000);
		approveByManager(true);
		approveByPresident(false);
		checkTasks(pi);
	} 
    /**
     * 生成流程实例 
     */
    protected ProcessInstance createProcessInstance(String user){
        System.out.println("==FirstFlowProcessTest.createProcessInstance()==");
        JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
        try {
        	 GraphSession graphSession = jbpmContext.getGraphSession();
             /*
              * 从数据库获取指定的流程定义
              */
        	 ProcessDefinition pdf  = graphSession.findLatestProcessDefinition("simple");
        	 //生成流程实例
        	 ProcessInstance pi = pdf.createProcessInstance();
        	 //设置流程发起人
        	 pi.getContextInstance().createVariable("initiator", user);
        	 //触发流程转向
        	 pi.signal();
        	 /*
        	  * 保存流程实例 
        	  */
        	 jbpmContext.save(pi);        	 
        	 return pi;
        }finally{
        	jbpmContext.close();
        }
    }
    
    /**
     * 填写提交申请单
     * @param money
     */
    @SuppressWarnings("unchecked")
    protected void submitApplication(String actorId , int money){
        System.out.println("==FirstFlowProcessTest.submitApplication()=="); 
    	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
	    try {  	
            /*
             *根据操作者ID，获取属于该操作者的任务集

             */
	        List<TaskInstance> taskInstances = jbpmContext.getTaskList(actorId);	        
	        for(TaskInstance ti : taskInstances){
		        System.out.println("ti.name = " + ti.getName());
		        System.out.println("ti.actor = " + ti.getActorId());
		        ContextInstance ci = ti.getContextInstance();
		        ci.setVariable("money",new Integer(money));
		        ti.end();
	        }	        
	    }finally{
	    	jbpmContext.close();	
	    }
    }
    
    /**
     * 部门经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByManager(boolean pass){    	
        System.out.println("==FirstFlowProcessTest.approveByManager()==");
    	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
    	try{
    		List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");
    		for(TaskInstance ti : taskInstances){    		
				System.out.println("ti.name = " + ti.getName());
				System.out.println("ti.actor = " + ti.getActorId());
			     if(pass){
                	 ti.end("部门经理审批通过");    	
                }else{
                	ti.end("部门经理驳回");
                } 			
    		}
    	}finally{
    		jbpmContext.close();
    	}
    }
    
    /**
     * 总经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByPresident(boolean pass){
    	System.out.println("==FirstFlowProcessTest.approveByPresident()==");    	
    	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
    	try{
    		List<TaskInstance> taskInstances = jbpmContext.getTaskList("President");
    		for(TaskInstance ti : taskInstances){
    			System.out.println("ti.name = " + ti.getName());
				System.out.println("ti.actor = " + ti.getActorId());
			     if(pass){
                	 ti.end("总经理审批通过");    	
                }else{
                	ti.end("总经理驳回");
                }
			}
    	}finally{
    		jbpmContext.close();
    	}
    }
    
    /**
     * 打印任务记录
     */
    @SuppressWarnings("unchecked")
	protected void checkTasks(ProcessInstance pi){       
        System.out.println("==FirstFlowProcessTest.checkTasks()==");
        JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
    	try{    				
	        List<TaskInstance> coll = jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance(pi);	
	        System.out.println("====Process has task:====");	
	        for(TaskInstance ti : coll){	
	               System.out.println("=="+ti.getName()+"==");	
	               System.out.println("=="+ti.getActorId()+"==");	
	               System.out.println("=="+ti.getVariables().toString() +"==");	
	        }	
	        System.out.println("====end====");
    	}finally{
    		jbpmContext.close();
    	}
    }    
}

相对于简单流程测试案例，标准流程的业务是相同的。它们的不同点在于：简单流程通过XML载入流程定义，并使用类的全局变量来保存流程实例的引用；而标准流程则是通过数据库载入流程定义，并使用数据库的会话来维护流程的运行。

1. 从数据库载入流程定义

Java代码

 JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();

	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();

从jBPM配置环境中获取jBPM上下文实例，jbpmContext是对jbpm持久层操作API及上下文环境的封装，它根据jBPM的配置文件生成。


Java代码

GraphSession graphSession = jbpmContext.getGraphSession();

GraphSession graphSession = jbpmContext.getGraphSession();

生成对流程图操作的持久层会话


Java代码

ProcessDefinition pdf = graphSession.findLatestProcessDefinition("simple");

ProcessDefinition pdf  = graphSession.findLatestProcessDefinition("simple");

从数据库获取命名为“simple”的流程定义。

2. 新建流程实例，并存入数据库持久化


Java代码

ProcessInstance pi = pdf.createProcessInstance();

ProcessInstance pi = pdf.createProcessInstance();

根据流程定义生成实例。


Java代码

pi.getContextInstance().createVariable("initiator", user);
pi.signal();

pi.getContextInstance().createVariable("initiator", user);
pi.signal();

设置实例的上下文变量，激活实例执行进程。


Java代码

jbpmContext.save(pi);

jbpmContext.save(pi);

保存实例到数据库，持久化实例。

3. 从数据库获取属于指定操作者的任务集

Java代码

JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try{
List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");
for(TaskInstance ti : taskInstances){
System.out.println("ti.name = " + ti.getName());
System.out.println("ti.actor = " + ti.getActorId());
if(pass){
ti.end("部门经理审批通过");
}else{
ti.end("部门经理驳回");
}
}
}finally{
jbpmContext.close();
}

JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
try{
    	List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");
    	for(TaskInstance ti : taskInstances){
		System.out.println("ti.name = " + ti.getName());
		System.out.println("ti.actor = " + ti.getActorId());
		if(pass){
            	 ti.end("部门经理审批通过");    	
         }else{
            	ti.end("部门经理驳回");
         }
	}	
}finally{
	jbpmContext.close();
}

通过JbpmContext对象，从数据库获取指定操作者的任务集合：

Java代码

List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");

List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");

注意，在每次的JbpmContext对象使用完毕后，一定要执行jbpmContext.close()，其本质是要释放数据库的操作连接。

你可能感兴趣的:(数据库,exception,jbpm,action,任务,transition)

2020-01-25 晴岚85
郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
2022-04-18 Apbenz
语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
关于提高复杂业务逻辑代码可读性的思考编程经验分享开发经验 java 数据库开发语言
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twitter easyui 前端 python
#使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
【PG】常见数据库、表属性设置江无羡数据库
PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
2019-3-23晨间日记红红火火小耳朵
今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
ios GCD _Waiting_
1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解秋刀prince mysql mysql 数据库
提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
为什么你总是对下属不满意? ZhaoWu1050
【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
BART&BERT Ambition_LAO 深度学习
BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
2020-8-19晨间日记：看过的电影盐大虾
今天是周三起床：6点半就寝：11点天气：晴心情：正常纪念日：周三任务清单今日完成的任务，最重要的三件事：1.整理写过的文档2.电影《电灯泡》3.这就是街舞第三季第五期改进：早睡早起习惯养成：早睡早起，看书周目标·完成进度两篇文章学习·信息·阅读电影艺术发展史相关教材健康·饮食·锻炼吃了挺多零食，还喝了果粒橙，还是得少吃，多锻炼，不然会慢慢死掉的。人际·家人·朋友淡定交流，不放在心上。工作·思考专心
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
python批量读取tiff文件_Python Pillow批量转换tif格式到jpg weixin_39557797
最近因为想要整下网站的壁纸，从网站下载了别人整理好的合集压缩包，解压之后，却发现里面的文件都是tif的，tif格式网站和电脑都不认的，根本不能作壁纸。这时候，就需要转换图片格式了，首先我找了几款转换格式的软件，发现效果都不好，要不是不支持tif格式，要不就是转换出来的图片糊的不行。最终，还是决定用Python的Pillow库来写一个脚本，完成这个任务。下面是整个的小脚本----importosim
Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 error react mongodb 数据库
背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
入门MySQL——查询语法练习 K_un
前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
放松的一天 4da9b7687fa0
20190325总结起床07:20图片发自App睡觉:23:00天气:晴今日任务清单学习·信息·阅读•水滴阅读Day40Alice’sAdventuresinWonderlandChapter6.2图片发自App•BBC跟读训练营Day24图片发自App图片发自App图片发自App•潘多拉口语训练营Day6Wow.Whatabigboy!•文化知识学习今日无•阅读时间地狱健康·饮食·锻炼•饮食目标
[Unity]在场景中随机生成不同位置且不重叠的物体 Bartender_Jill Graphics图形学笔记 unity 游戏引擎动画
1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
ASM系列六利用TreeApi 添加和移除类成员 lijingyao8206 jvm 动态代理 ASM 字节码技术 TreeAPI
同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。 package asm.core; /** * Created by yunshen.ljy on 2015/6/
Springmvc-权限设计 bee1314 spring Web jsp
万丈高楼平地起。权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。目标： 1.实现权限的管理（CRUD） 2.实现部门管理（CRUD) 3.实现人员的管理（CRUD） 4.实现部门和权限
算法竞赛入门经典（第二版）第2章习题 CrazyMizzz c 算法
2.4.1 输出技巧 #include <stdio.h> int main() { int i, n; scanf("%d", &n); for (i = 1; i <= n; i++) printf("%d\n", i); return 0; } 习题2-2 水仙花数(daffodil
struts2中jsp自动跳转到Action 麦田的设计者 jsp webxml struts2 自动跳转
1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士） 2、＜jsp:forward page="xxx.action" /＞，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
php 操作webservice实例 IT独行者 PHP webservice
首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; OK 现在我们来体验webservice //server端 serve
Windows下使用Vagrant安装linux系统 _wy_ windows vagrant
准备工作：下载安装 VirtualBox ：https://www.virtualbox.org/ 下载安装 Vagrant ：http://www.vagrantup.com/ 下载需要使用的 box ：官方提供的范例：http://files.vagrantup.com/precise32.box 还可以在 http://www.vagrantbox.es/
更改linux的文件拥有者及用户组(chown和chgrp) 无量 c linux chgrp chown
本文（转） http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/ http://ydlmlh.iteye.com/blog/1435157 一、基本使用：使用chown命令可以修改文件或目录所属的用户：命令
linux下抓包工具矮蛋蛋 linux
原文地址： http://blog.chinaunix.net/uid-23670869-id-2610683.html tcpdump -nn -vv -X udp port 8888 上面命令是抓取udp包、端口为8888 netstat -tln 命令是用来查看linux的端口使用情况 13 . 列出所有的网络连接 lsof -i 14. 列出所有tcp 网络连接信息 l
我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起” alafqq mybatis
最近看了每一个用mybatis的男纸，你伤不起原文地址：http://www.iteye.com/topic/1073938 发表一下个人看法。欢迎大神拍砖；个人一直使用的是Ibatis框架，公司对其进行过小小的改良；最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究；发现多了一个mapper层；个人感觉就是个dao；
解决java数据交换之谜百合不是茶数据交换
交换两个数字的方法有以下三种，其中第一种最常用 /* 输出最小的一个数 */ public class jiaohuan1 { public static void main(String[] args) { int a =4; int b = 3; if(a<b){ // 第一种交换方式 int tmep =
渐变显示 bijian1013 JavaScript
<style type="text/css"> #wxf { FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98); height: 25px; } </style>
探索JUnit4扩展：断言语法assertThat bijian1013 java 单元测试 assertThat
一.概述 JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}} bit1129 gson
如何把如下简单的JSON字符串反序列化为Java的POJO对象? {"data":{"IM":["MSN","QQ","Gtalk"]}} 下面的POJO类Model无法完成正确的解析： import com.google.gson.Gson;
【Kafka九】Kafka High Level API vs. Low Level API bit1129 kafka
1. Kafka提供了两种Consumer API High Level Consumer API Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题
在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua
Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
java-归并排序 bylijinnan java
import java.util.Arrays; public class MergeSort { public static void main(String[] args) { int[] a={20,1,3,8,5,9,4,25}; mergeSort(a,0,a.length-1); System.out.println(Arrays.to
Netty源码学习-CompositeChannelBuffer bylijinnan java netty
CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 查看API（ http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description）可以看到，所谓“Transparent Zero Copy”是通
Android中给Activity添加返回键 hotsunshine Activity
// this need android:minSdkVersion="11" getActionBar().setDisplayHomeAsUpEnabled(true); @Override public boolean onOptionsItemSelected(MenuItem item) {
静态页面传参 ctrain 静态
$(document).ready(function () { var request = { QueryString : function (val) { var uri = window.location.search; var re = new RegExp("" + val + "=([^&?]*)", &
Windows中查找某个目录下的所有文件中包含某个字符串的命令 daizj windows 查找某个目录下的所有文件包含某个字符串
findstr可以完成这个工作。 [html] view plain copy >findstr /s /i "string" *.* 上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
改善程序代码质量的一些技巧 dcj3sjt126com 编程 PHP 重构
有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：尽量保持方法简短尽管很多人都遵
SharedPreferences对数据的存储 dcj3sjt126com
SharedPreferences简介： &nbs
linux复习笔记之bash shell (2) bash基础 eksliang bash bash shell
转载请出自出处： http://eksliang.iteye.com/blog/2104329 1.影响显示结果的语系变量（locale） 1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： [root@localhost shell]# locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8"
Android零碎知识总结 gqdy365 android
1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
HoverTree.Model.ArticleSelect类的作用 hvt Web .net C#hovertree asp.net
ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
PHP 判断是否使用代理 PHP Proxy Detector 天梯梦 proxy
1. php 类 I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to
apache的math库中的回归——regression（翻译） lvdccyb Math apache
这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。基本覆盖了：线代，统计，矩阵，最优化理论曲线拟合常微分方程遗传算法（GA），还有3维的运算。。。
基础数据结构和算法十三：Undirected Graphs (2) sunwinner Algorithm
Design pattern for graph processing. Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
云计算平台最重要的五项技术 sumapp 云计算云平台智城云
云计算平台最重要的五项技术 1、云服务器云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。特性机型丰富通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作；仅需要几分钟，根据CP
《京东技术解密》有奖试读获奖名单公布 ITeye管理员活动
ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 12月试读活动回顾： http://webmaster.iteye.com/blog/2164754 本次技术图书试读活动获奖名单及相应作品如下：一等奖（两名） Microhardest：http://microhardest.ite