【代码篇】JBPM4.4开发流程节点（动态代理实现流程管理业务）

继之前的博客，【思想篇】工作流技术JBPM4.4开发入门（四），【思想篇】工作流技术JBPM4.4开发入门（五）本篇博客来结合代码简单说说，如何让流程来管理业务：

 

先来看看我们抽出来的代理类：

 

StartAbstractJBPM：流程启动节点

[java] view plain copy

print?

1. package com.hjy.ssh.action;  
2. import com.hjy.ssh.beans.AbstractApply;  
3. import java.lang.reflect.Method;  
4. import java.lang.reflect.Proxy;  
5.   
6. import javax.annotation.Resource;  
7. import org.jbpm.api.ProcessInstance;  
8. import org.springframework.context.annotation.Scope;  
9. import org.springframework.stereotype.Controller;  
10.   
11. import java.lang.reflect.InvocationHandler;  
12.   
13. import java.util.Map;  
14. import com.hjy.ssh.service.JBPMService;  
15. import com.opensymphony.xwork2.ActionSupport;  
16.   
17. @Controller  
18. @Scope("prototype")  
19. public class StartAbstractJBPM extends ActionSupport {  
20.   
21.         private static final long serialVersionUID = 1L;  
22.           
23.         //定义一个属性变量  
24.         private Map<String, Object> variablesMap;  
25.         private String pdKey;  
26.         protected JBPMService jbpmService;  
27.           
28.         public void common(String pdKey,Map<String, Object> variablesMap,JBPMService jbpmService){  
29.             this.variablesMap=variablesMap;  
30.             this.pdKey=pdKey;  
31.             this.jbpmService=jbpmService;  
32.         }  
33.         //想尝试能否根据其他方式传参，new的话太耗费资源  
34.         /*public StartAbstractJBPM(String pdKey,Map<String, Object> variablesMap,JBPMService jbpmService){ 
35.             this.variablesMap=variablesMap; 
36.             this.pdKey=pdKey; 
37.             this.jbpmService=jbpmService; 
38.         }*/  
39.                           
40.           
41.         //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类       
42.         public class LogHandler1 implements InvocationHandler{          
43.         // 目标对象    
44.         private Object targetObject;    
45.         //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。                
46.         public Object newProxyInstanceStart(Object targetObject){    
47.             this.targetObject=targetObject;    
48.             //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例      
49.             //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器    
50.             //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口    
51.             //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法    
52.             //根据传入的目标返回一个代理对象    
53.             return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),    
54.                     targetObject.getClass().getInterfaces(),this);    
55.         }    
56.             
57.         @Override    
58.         //关联的这个实现类的方法被调用时将被执行    
59.        // InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数    
60.         public Object invoke(Object proxy, Method method, Object[] args)    
61.                 throws Throwable {    
62.             System.out.println("start-->>");    
63.             for(int i=0;i<args.length;i++){    
64.                 System.out.println(args[i]);    
65.             }    
66.             Object ret=null;    
67.             try{    
68.                 //原对象方法调用前处理日志信息    
69.                 System.out.println("satrt-->>");   
70.                                    
71.                 //启动流程                   
72.                 ProcessInstance pi=(ProcessInstance) jbpmService.startProcessInstanceByKey(pdKey,variablesMap);  
73.                   
74.                 //调用目标方法    
75.                 AbstractApply abstractApply=(AbstractApply)args[0];  
76.                 abstractApply.setExecuteId(pi.getId());  
77.                 args[0]=abstractApply;  
78.                 ret=method.invoke(targetObject, args);    
79.                   
80.                 //调用完成当前结点  
81.                 // >> 办理完第1个任务“提交申请”        
82.                 jbpmService.completeFirstTask(pi);    
83.                   
84.                 //原对象方法调用后处理日志信息    
85.                 System.out.println("success-->>");    
86.             }catch(Exception e){    
87.                 e.printStackTrace();    
88.                 System.out.println("error-->>");    
89.                 throw e;    
90.             }    
91.             return ret;    
92.         }  
93.                       
94.         }     
95.   
96. }  

HandleAbstractJBPMAction：任务办理节点

[java] view plain copy

print?

1. package com.hjy.ssh.action;  
2.   
3.   
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. import javax.annotation.Resource;  
8. import org.jbpm.api.ProcessInstance;  
9.   
10. import java.lang.reflect.InvocationHandler;  
11. import com.hjy.ssh.service.JBPMService;  
12.   
13.   
14. public abstract class HandleAbstractJBPMAction<T> extends ModelDrivenBaseAction<T> {  
15.       
16.     protected String outcome;//分支  
17.     protected String taskId;//任务id  
18.     protected boolean approval;//是否同意  
19.     @Resource  
20.     protected JBPMService jbpmService;  
21.       
22.       
23.     //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类       
24.     public class LogHandler implements InvocationHandler{       
25.         // 目标对象    
26.         private Object targetObject;    
27.         //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。                
28.         public Object newProxyInstance(Object targetObject){    
29.             this.targetObject=targetObject;    
30.             //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例      
31.             //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器    
32.             //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口    
33.             //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法    
34.             //根据传入的目标返回一个代理对象    
35.             return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),    
36.                     targetObject.getClass().getInterfaces(),this);    
37.         }    
38.         @Override    
39.         //关联的这个实现类的方法被调用时将被执行    
40.        // InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数    
41.         public Object invoke(Object proxy, Method method, Object[] args)    
42.                 throws Throwable {    
43.             System.out.println("start-->>");    
44.             for(int i=0;i<args.length;i++){    
45.                 System.out.println(args[i]);    
46.             }    
47.             Object ret=null;    
48.             try{    
49.                 //原对象方法调用前处理日志信息    
50.                 System.out.println("satrt-->>");   
51.                   
52.                 //保存处理信息  
53.                 //abstractApprove();       
54.                   
55.                 // 2，办理当前任务,调用完成当前结点  
56.                 ProcessInstance pi=jbpmService.completeTask(taskId, outcome);                                             
57.                 //调用工作流的操作  
58.                 if(approval==false){  
59.                     if (pi != null) { // 如果流程还未结束                     
60.                         //结束当前流程                  
61.                         jbpmService.endProcessInstance(pi);  
62.                     }  
63.                 }                 
64.                     
65.                 //调用目标方法    
66.                 ret=method.invoke(targetObject, args);    
67.                   
68.                 //调用工作流，每个都实现这么一个接口就可以，判断是否要修改  
69.                 isEnd(pi);              
70.                 //原对象方法调用后处理日志信息    
71.                 System.out.println("success-->>");    
72.             }catch(Exception e){    
73.                 e.printStackTrace();    
74.                 System.out.println("error-->>");    
75.                 throw e;    
76.             }    
77.             return ret;    
78.         }  
79.           
80.           
81.     }    
82.     // 抽象方法，实现保存处理信息，以及设置同意不同意，但不需要更新     
83.     protected abstract void abstractApprove()throws Exception;  
84.           
85.     // 抽象方法，如果为最后的结点且同意了，那么需要更新的数据表  
86.     protected abstract void isEnd(ProcessInstance pi);  
87.   
88.     //-----------  
89.       
90.     public String getOutcome() {  
91.         return outcome;  
92.     }  
93.   
94.     public void setOutcome(String outcome) {  
95.         this.outcome = outcome;  
96.     }  
97.   
98.     public String getTaskId() {  
99.         return taskId;  
100.     }  
101.   
102.     public void setTaskId(String taskId) {  
103.         this.taskId = taskId;  
104.     }  
105.   
106.     public boolean isApproval() {  
107.         return approval;  
108.     }  
109.   
110.     public void setApproval(boolean approval) {  
111.         this.approval = approval;  
112.     }  
113.   
114. }  

注：以上的代理使用了两种方式传值，由于java不支持多重继承，故第一种方式更好些，但是第二种方式传值更加简单，大家根据需要来选择即可！

 

以上这两个是抽象出来的代理类，那么它起到了什么作用呢？

下面我们来一起看看它们的应用：

 

对应启动节点：

[java] view plain copy

print?

1. /** 提交申请 ,启动工作流--想成是宿主程序*/  
2. public String edit() throws Exception {  
3.               
4.     Long stuCourseId=model.getId();  
5.     //提交申请  
6.     //封装申请信息，学生的申请信息  
7.     StuCourseApply stuCourseApply = new StuCourseApply();  
8.     stuCourseApply.setStuCourseId(stuCourseId);  
9.     newCourse=new String(newCourse.getBytes("iso-8859-1"),"utf-8");       
10.     newTeacher=new String(newTeacher.getBytes("iso-8859-1"),"utf-8");         
11.     stuCourseApply.setApplicant(getCurrentUser()); // 申请人，当前用户    
12.     stuCourseApply.setOldCourse(model.getCourse());  
13.     stuCourseApply.setNewCourse(newCourse);  
14.     stuCourseApply.setNewTeacher(newTeacher);  
15.     stuCourseApply.setOldTeacher(model.getTeacher());  
16.     stuCourseApply.setTitle("修改课程信息");  
17.     String processDefinitionKeyStr=new String(processDefinitionKey.getBytes("iso-8859-1"),"utf-8");  
18.     stuCourseApply.setProcessDefinitionKey(processDefinitionKeyStr);  
19.   
20.     // 调用业务方法（保存申请信息）  
21.       
22.     // 1，设置属性并保存stuCourseApply  
23.     stuCourseApply.setApplyTime(sdf.format(new Date())); // 申请时间，当前时间  
24.     stuCourseApply.setStatus(StuCourseApply.STATUS_RUNNING);  
25.     //两次保存？  
26.     stuCourseApplyService.save(stuCourseApply);       
27.       
28.     // 2， 准备流程变量  
29.     Map<String, Object> variablesMap = new HashMap<String, Object>();  
30.     variablesMap.put("stuCourseApply", stuCourseApply);  
31.               
32.       
33.     //获取流程定义的key                  
34.     String pdKey = stuCourseApply.getProcessDefinitionKey();          
35.       
36.     // 3，启动流程实例开始流转，并带上流程变量（当前的申请信息）,调用宿主程序               
37.     // 调用业务，保存申请信息        
38.     startAbstractJBPM.common(pdKey, variablesMap, jbpmService);  
39.     StartAbstractJBPM.LogHandler1 logHandler = startAbstractJBPM.new LogHandler1();  
40.     //放到代理中设置值了  
41.     //stuCourseApply.setExecuteId(pi.getId());  
42.       
43.     StuCourseApplyService stuCourseApplyService1=(StuCourseApplyService)logHandler.newProxyInstanceStart(stuCourseApplyService);          
44.     stuCourseApplyService1.save(stuCourseApply);      
45.                       
46.     return "toStuApplicationList"; // 成功后转到"我的申请查询"               
47.               
48. }  

对应办理节点：

[java] view plain copy

print?

1. /** 审批处理 */  
2. public String approve() throws Exception {    
3.     abstractApprove();  
4.     // 应用代理  
5.     LogHandler logHandler=new LogHandler();           
6.     // 调用业务，更新状态,更新状态之前会先调用工作流的完成当前任务方法  
7.     StuCourseApplyService stuCourseApplyService1=(StuCourseApplyService)logHandler.newProxyInstance(stuCourseApplyService);    
8.     stuCourseApplyService1.update(stuCourseApply);        
9.       
10.     return "toStuTaskList"; // 成功后转到待我审批页面  
11. }  

通过这两段代码，相信大家可以看出在这两段代码中已经不存在工作流的任何内容，而此时我们的流程却依然被工作流来管理着，也就是我们将所有有关工作流的方法均抽象出来，让我们的类单纯的应对业务，在调用业务的方法时我们调用代理，而此时的代理中已经将工作流的启动办理等一系列操作封装进去，在我们调用代理方法时已经启动了工作流，再处理时也操作了工作流的办理，故整个业务流程在我们无需了解工作流的情况下就已经实现了被流程管理。

我们一直在说AOP，那么什么是AOP？

AOP（AspectOrientedProgramming）：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码---两个字概括：解耦。

 

总结：

最想说的一句话：会者不难，难者不会。在学习工作流的这段期间，各种的不理解，各种的质疑自己，这个是AOP吗？这样做是我们想要的吗？有时候仍会问自己什么是工作流，说到底它到底给我们带来了什么好处？

工作流(Workflow)，就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”这段话说的真的很棒，但是我觉得我们要做到的不仅仅是这些，要补充的一点就是实现工作流的AOP！