`

【转】 一个请假单流程的实现(struts2.1.8+spring2.5+hibernate3集成jbpm4.3)

    博客分类：
  • jbpm
jbpm 
阅读更多

 

网上随便找了个请假的流程图，在此先谢谢提供图片的人：



使用jbpm工具画出流程图，中文好像是乱码，所以改为英文：

 


 leave.jpdl.xml内容：

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <process name="leave" xmlns="http://jbpm.org/4.3/jpdl">  
  4.    <start g="159,47,48,48" name="start1">  
  5.       <transition to="exclusive1"/>  
  6.    </start>  
  7.    <decision expr="#{job}" g="161,152,48,48" name="exclusive1">  
  8.       <transition g="42,179:43,-27" name="isChief" to="boosApprove"/>  
  9.       <transition g="316,175:-83,-23" name="isnotChief" to="chiefApprove"/>  
  10.    </decision>  
  11.    <state g="-3,220,92,52" name="boosApprove">  
  12.       <transition g="47,340:" to="sendEmail"/>  
  13.    </state>  
  14.    <state g="270,214,92,52" name="chiefApprove">  
  15.       <transition to="exclusive2"/>  
  16.    </state>  
  17.    <decision expr="#{day}" g="160,219,48,48" name="exclusive2">  
  18.       <transition g="-2,-20" name="gt10" to="boosApprove"/>  
  19.       <transition g="186,323:12,-47" name="le10" to="sendEmail"/>  
  20.    </decision>  
  21.    <end g="171,410,48,48" name="end"/>  
  22.    <state g="146,313,92,52" name="sendEmail">  
  23.       <transition to="end"/>  
  24.    </state>  
  25.        
  26. </process>  


分析之后，有如下一些表：
用户user_
角色role_(简化到user_)
请假单leave_
假设有这么几个用户：
陈均  --普通员工
唐平 --级别最高的，BOOS，老板
胡杰 --级别比较高的，chief主管
张小 --普通员工
用户测试数据：

Sql代码 复制代码
  1. INSERT INTO `user_` VALUES ('9', '陈均', '普通员工');   
  2. INSERT INTO `user_` VALUES ('10', '胡杰', '主管');   
  3. INSERT INTO `user_` VALUES ('11', '唐平', '老板');   
  4. INSERT INTO `user_` VALUES ('12', '张小', '普通员工');  

 

现在集成jbpm4.3,hibernate3,spring2.5,struts2.1.8。

 系统初步设计如图：



1.因为jbpm里面带有hibernate，所以创建web项目后，导入jbpm-4.3\lib下的所有包，导入jbpm-4.3\jbpm.jar,
把jbpm4.3\lib\下面得juel.jar，juel-engine.jar，juel-impl.jar放到tomcat的lib下面。导入spring2.5的jar，导入struts2.1.8所需jar包。以下jar包不是最简，有些不是必须的。

spring2.5所需jar包清单：
aspectjrt.jar
aspectjweaver.jar
cglib-nodep-2.1_3.jar
common-annotations.jar
commons-logging.jar
log4j-1.2.15.jar
spring.jar
spring-webmvc-struts.jar
------------------------------------
struts2.1.8所需jar包清单：
commons-fileupload-1.2.1.jar
commons-io-1.3.2.jar
freemarker-2.3.15.jar
ognl-2.7.3.jar
struts2-core-2.1.8.1.jar
struts2-dojo-plugin-2.1.8.1.jar
struts2-spring-plugin-2.1.8.1.jar
xwork-core-2.1.6.jar
-----------------------------------
数据库和数据源所需jar包：
c3p0-0.9.1.2.jar
mysql-connector-java-5.1.7-bin.jar
找到jbpm-4.3\install\src\cfg\jbpm\下的spring.jbpm.cfg.xml文件，放入项目的src处，改名为jbpm.cfg.xml.

在项目src下面创建applicationContext.xml配置文件，内容如下：

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
  4.     xmlns:context="http://www.springframework.org/schema/context"  
  5.      xmlns:p="http://www.springframework.org/schema/p"  
  6.     xmlns:aop="http://www.springframework.org/schema/aop"    
  7.     xmlns:tx="http://www.springframework.org/schema/tx"  
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  9.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  10.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
  11.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  12.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  13.   
  14.     <!-- 开启注解配置 -->  
  15.     <context:annotation-config />  
  16.        
  17.     <!-- 对指定的包进行组件扫描 -->  
  18.     <context:component-scan base-package="org.forever.leave" />  
  19.   
  20.     <!-- 配置数据源,导入c3p0-0.9.1.2.jar,mysql-connector-java-5.1.7-bin.jar -->  
  21.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
  22.         destroy-method="close">  
  23.         <property name="driverClass">  
  24.             <value>com.mysql.jdbc.Driver</value>  
  25.         </property>  
  26.         <property name="jdbcUrl">  
  27.             <value>jdbc:mysql://localhost:3306/jbpmdb</value>  
  28.         </property>  
  29.         <property name="user">  
  30.             <value>root</value>  
  31.         </property>  
  32.         <property name="password">  
  33.             <value>root</value>  
  34.         </property>  
  35.     </bean>  
  36.   
  37.     <!-- 集成hibernate配置 -->  
  38.     <bean id="sessionFactory"  
  39.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  40.         <property name="dataSource" ref="dataSource" />  
  41.         <property name="hibernateProperties" ref="hibernateProperties" />  
  42.         <property name="mappingLocations">  
  43.             <list>  
  44.                 <value>classpath*:org/forever/leave/entities/*.hbm.xml</value>  
  45.                 <value>classpath:jbpm.repository.hbm.xml</value>      
  46.                 <!-- 以下几个jbpm.*.hbm.xml由jBPM自带 -->                      
  47.                 <value>classpath:jbpm.execution.hbm.xml</value>      
  48.                 <value>classpath:jbpm.history.hbm.xml</value>      
  49.                 <value>classpath:jbpm.task.hbm.xml</value>      
  50.                 <value>classpath:jbpm.identity.hbm.xml</value>    
  51.             </list>  
  52.         </property>  
  53.     </bean>  
  54.        
  55.     <bean name="hibernateProperties"  
  56.         class="org.springframework.beans.factory.config.PropertiesFactoryBean">  
  57.         <property name="properties">  
  58.             <props>  
  59.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
  60.                 <prop key="hibernate.show_sql">true</prop>  
  61.                 <prop key="hibernate.hbm2ddl.auto">update</prop>  
  62.             </props>  
  63.         </property>  
  64.     </bean>  
  65.   
  66.     <!-- jbpm配置 -->  
  67.     <bean id="springHelper" class="org.jbpm.pvm.internal.processengine.SpringHelper" />  
  68.     <bean id="processEngine" factory-bean="springHelper"  
  69.         factory-method="createProcessEngine" />  
  70.        
  71.     <!-- 模板配置自己写的，不是必须的 -->  
  72.     <bean id="jbpmTemplate" class="org.forever.leave.jbpm.JbpmTemplate">  
  73.         <property name="processEngine" ref="processEngine"></property>  
  74.     </bean>  
  75.        
  76.     <!-- 数据层用的模板工具，不是必须的 -->  
  77.     <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">  
  78.         <property name="sessionFactory" ref="sessionFactory"></property>  
  79.     </bean>  
  80.   
  81.     <!-- 事务配置，必须 -->  
  82.     <bean id="transactionManager"  
  83.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  84.         <property name="sessionFactory" ref="sessionFactory" />  
  85.     </bean>  
  86.   
  87.     <!-- 切面配置 -->  
  88.     <aop:config>  
  89.         <aop:pointcut expression="execution(* org.forever.leave.service..*.*(..))"  
  90.             id="transactionPointcut" />  
  91.         <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut" />  
  92.     </aop:config>  
  93.     <!-- 通知配置 -->  
  94.     <tx:advice id="txAdvice" transaction-manager="transactionManager">  
  95.         <tx:attributes>  
  96.             <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" />  
  97.             <tx:method name="find*" read-only="true" propagation="NOT_SUPPORTED" />  
  98.             <tx:method name="*" propagation="REQUIRED" />  
  99.         </tx:attributes>  
  100.     </tx:advice>  
  101.   
  102.   
  103.   
  104. </beans>  


添加 log4j.properties文件；
模板类JbpmTemplate:
Java代码 复制代码
  1. package org.forever.leave.jbpm;   
  2.   
  3. import org.jbpm.api.ExecutionService;   
  4. import org.jbpm.api.HistoryService;   
  5. import org.jbpm.api.ManagementService;   
  6. import org.jbpm.api.ProcessEngine;   
  7. import org.jbpm.api.ProcessInstance;   
  8. import org.jbpm.api.RepositoryService;   
  9. import org.jbpm.api.TaskService;   
  10.   
  11. /**  
  12.  * jbpm模板类(初步实现)  
  13.  *   
  14.  * @author Administrator  
  15.  *   
  16.  */  
  17. public class JbpmTemplate {   
  18.   
  19.     /**  
  20.      * 部署流程到数据库  
  21.      *   
  22.      * @param resourceName  
  23.      *            资源文件名字 比如(org/forever/jbpm/jpdl/process.jpdl.xml)  
  24.      * @return 返回流程定义id(格式：key-version)  
  25.      */  
  26.     public String Deploy(String resourceName) {   
  27.         return repositoryService.createDeployment().addResourceFromClasspath(   
  28.                 resourceName).deploy();   
  29.     }   
  30.   
  31.     /**  
  32.      * 创建一个新的流程实例  
  33.      *   
  34.      * @param processDefinitionKey  
  35.      *            (process.jpdl.xml中process标签的key)  
  36.      * @param processInstanceKey  
  37.      *            (用户给的key,可以使用uuid等)  
  38.      * @return 流程实例  
  39.      */  
  40.     public ProcessInstance addProcessInstance(String processDefinitionKey,   
  41.             String processInstanceKey) {   
  42.         return executionService.startProcessInstanceByKey(processDefinitionKey,   
  43.                 processInstanceKey);   
  44.   
  45.     }   
  46.   
  47.     /**  
  48.      * 根据key获取流程实例(这里我使用的uuid)  
  49.      *   
  50.      * @param key  
  51.      *            (对应于数据库表jbpm4_execution中的KEY_字段)  
  52.      * @return 返回查找到得流程实例，没有返回null  
  53.      */  
  54.     public ProcessInstance getProcessInstance(String key) {   
  55.         return executionService.createProcessInstanceQuery()   
  56.                 .processInstanceKey(key).uniqueResult();   
  57.     }   
  58.   
  59.     /**  
  60.      * 彻底删除文件的部署  
  61.      *   
  62.      * @param deploymentId流程定义id  
  63.      */  
  64.     public void deleteDeploymentCascade(String deploymentId) {   
  65.         repositoryService.deleteDeploymentCascade(deploymentId);   
  66.     }   
  67.   
  68.     public JbpmTemplate() {   
  69.            
  70.     }   
  71.   
  72.     public JbpmTemplate(ProcessEngine processEngine) {   
  73.         this.processEngine = processEngine;   
  74.         repositoryService = processEngine.getRepositoryService();   
  75.         executionService = processEngine.getExecutionService();   
  76.         taskService = processEngine.getTaskService();   
  77.         historyService = processEngine.getHistoryService();   
  78.         managementService = processEngine.getManagementService();   
  79.     }   
  80.   
  81.     private ProcessEngine processEngine;   
  82.     private RepositoryService repositoryService = null;   
  83.     private ExecutionService executionService = null;   
  84.     private TaskService taskService = null;   
  85.     private HistoryService historyService = null;   
  86.     private ManagementService managementService = null;   
  87.   
  88.     public ProcessEngine getProcessEngine() {   
  89.         return processEngine;   
  90.     }   
  91.   
  92.     public void setProcessEngine(ProcessEngine processEngine) {   
  93.         this.processEngine = processEngine;   
  94.         System.out.println(processEngine);   
  95.         repositoryService = processEngine.getRepositoryService();   
  96.         executionService = processEngine.getExecutionService();   
  97.         taskService = processEngine.getTaskService();   
  98.         historyService = processEngine.getHistoryService();   
  99.         managementService = processEngine.getManagementService();   
  100.     }   
  101.   
  102.     public RepositoryService getRepositoryService() {   
  103.         return repositoryService;   
  104.     }   
  105.   
  106.     public void setRepositoryService(RepositoryService repositoryService) {   
  107.         this.repositoryService = repositoryService;   
  108.     }   
  109.   
  110.     public ExecutionService getExecutionService() {   
  111.         return executionService;   
  112.     }   
  113.   
  114.     public void setExecutionService(ExecutionService executionService) {   
  115.         this.executionService = executionService;   
  116.     }   
  117.   
  118.     public TaskService getTaskService() {   
  119.         return taskService;   
  120.     }   
  121.   
  122.     public void setTaskService(TaskService taskService) {   
  123.         this.taskService = taskService;   
  124.     }   
  125.   
  126.     public HistoryService getHistoryService() {   
  127.         return historyService;   
  128.     }   
  129.   
  130.     public void setHistoryService(HistoryService historyService) {   
  131.         this.historyService = historyService;   
  132.     }   
  133.   
  134.     public ManagementService getManagementService() {   
  135.         return managementService;   
  136.     }   
  137.   
  138.     public void setManagementService(ManagementService managementService) {   
  139.         this.managementService = managementService;   
  140.     }   
  141.   
  142. }  

创建测试类Test：
Java代码 复制代码
  1. import java.util.UUID;   
  2.   
  3. import org.forever.leave.jbpm.JbpmTemplate;   
  4. import org.jbpm.api.ProcessInstance;   
  5. import org.springframework.context.ApplicationContext;   
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  7.   
  8. public class Test {   
  9.   
  10.     public static void main(String[] args) {   
  11.         ApplicationContext context = new ClassPathXmlApplicationContext(   
  12.                 "applicationContext.xml");   
  13.   
  14.         JbpmTemplate jbpmTemplate = (JbpmTemplate) context   
  15.                 .getBean("jbpmTemplate");   
  16.         System.out.println(jbpmTemplate);   
  17.   
  18.         jbpmTemplate.Deploy("org/forever/leave/jbpm/jpdl/leave.jpdl.xml");   
  19.         UUID uuid = UUID.randomUUID();   
  20.     }   
  21. }  
控制台输出没有报错说明jbpm和spring初步集成成功；
访问http://localhost:8080/leave/user/queryList.action获取到用户列表信息，说明集成成功。
项目中需要修改mysql方言为org.hibernate.dialect.MySQLInnoDBDialect，事务service改为biz，刚发现的，呵呵
下一步进行业务的实现。
未完
因为朋友需要，所以对其进行了简单的实现：
在实现中发现集成的时候，如果你用mysql数据库，请设置你的方言为：org.hibernate.dialect.MySQLInnoDBDialect
先看一哈这个实现了简单业务的一个图，在此用的中文，也是网上找的：

 

对应xml文件：
Xml代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <process key="leave" name="leave" xmlns="http://jbpm.org/4.3/jpdl">  
  4.    <start g="201,14,48,48" name="开始">  
  5.       <transition g="-42,-10" name="请假" to="填写请假单"/>  
  6.    </start>  
  7.    <task assignee="writerForm" g="178,87,92,52" name="填写请假单">  
  8.       <transition g="-97,2" name="判断是不是经理" to="是不是经理"/>  
  9.    </task>  
  10.    <decision expr="#{manager}" g="204,158,48,48" name="是不是经理">  
  11.       <transition g="-23,-11" name="否" to="经理审核"/>  
  12.       <transition g="14,-11" name="是" to="老板审批"/>  
  13.    </decision>  
  14.    <task assignee="#{username}" g="103,252,92,52" name="经理审核">  
  15.       <transition g="150,450:10,-21" name="经理批准" to="结束"/>  
  16.       <transition g="-22,-22" name="请假天数>5" to="老板审批"/>  
  17.       <transition g="-61,-1" name="经理不批准" to="终止"/>  
  18.       <transition g="149,114:-55,82" name="经理驳回" to="填写请假单"/>  
  19.    </task>  
  20.      
  21.    <!-- 这里只有一个老板，所以写死了，如果有多个老板，写法同上,业务就会改变 -->  
  22.    <task assignee="张杰" g="278,251,92,52" name="老板审批">  
  23.       <transition g="326,450:-58,-24" name="老板批准" to="结束"/>  
  24.       <transition g="7,0" name="老板不批准" to="终止"/>  
  25.       <transition g="323,114:13,61" name="老板驳回" to="填写请假单"/>  
  26.    </task>  
  27.    <end g="219,429,48,48" name="结束" state="confirm"/>  
  28.    <end g="220,360,48,48" name="终止" state="dissent"/>  
  29. </process>  

 写了个经理审批的测试类过程：

Java代码  收藏代码
  1. package org.forever.leave.biz.test;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Date;  
  5. import java.util.HashMap;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8. import java.util.UUID;  
  9.   
  10. import org.forever.leave.entities.Leave;  
  11. import org.forever.leave.entities.User;  
  12. import org.jbpm.api.ProcessInstance;  
  13. import org.jbpm.api.task.Task;  
  14. import org.junit.Test;  
  15.   
  16. //请假测试  
  17. //运行顺序  
  18. //testDeploy()  
  19. //testCresteLeave()  
  20. //testStart()  
  21. //testGetTask()  
  22. //testGetLeave()  
  23. public class LeaveTest extends BaseTest{  
  24.       
  25.     //部署流程  
  26.     @Test  
  27.     public void testDeploy(){  
  28.         String resourceName ="org/forever/leave/jbpm/jpdl/leave.jpdl.xml";   
  29.         jbpmTemplate.Deploy(resourceName);  
  30.           
  31.     }  
  32.       
  33.     //新建请假单  
  34.     @Test  
  35.     public void testCresteLeave(){  
  36.           
  37.         //现假设用户陈均登陆了系统，然后进行请假  
  38.         String loginName = "cj";//登陆者  
  39.         String password = "cj";//登陆密码  
  40.         User user = userDao.get(loginName,password);  
  41.         //status=新建，就是未提交的  
  42.         UUID uuid = UUID.randomUUID();  
  43.         Leave leave = new Leave(user, 3,new Date(),"新建", "生病了");  
  44.         leave.setLeaveId(uuid.toString());  
  45.         //保存到数据库  
  46.         leaveDao.save(leave);  
  47.     }  
  48.       
  49.     // 启动流程实例,提交请假申请  
  50.     //注意（如果要对该测试类成功测试，首先确保存在juel-engine.jar，juel-impl.jar，juel.jar）  
  51.     //部署到tomcat里面的时候就把juel.jar，juel-engine.jar，juel-impl.jar放到tomcat的lib下面  
  52.     @Test  
  53.     public void testStart() {  
  54.         //进行业务流转所需的变量  
  55.         String loginName = "cj";//登陆者  
  56.         String password = "cj";//登陆密码  
  57.         User user = userDao.get(loginName,password);  
  58.         // 3.启动流程实例,绑定业务key,key最好是唯一的  
  59.         List<?> list = leaveDao.findByUserLeave(user.getUserId());//该用户可能有多次请假的记录  
  60.         //假设用户选择的是index=0的那个请假单  
  61.         Leave leave = (Leave)list.get(0);  
  62.           
  63.           
  64.         String position = user.getPosition();//用户的职位  
  65.         Map<String, Object> variables = new HashMap<String, Object>();//流程中要用到的变量信息  
  66.           
  67.         variables.put("leaveId",leave.getLeaveId());//存放该实例的请假单  
  68.           
  69.         if("员工".equals(position)){//如果是员工请假  
  70.             variables.put("manager", "否");  
  71.             variables.put("username","胡杰");//指定一个经理进行审批  
  72.               
  73.         }else if("经理".equals(position)){//如果是经理请假  
  74.             variables.put("manager", "是");  
  75.             //只有一个boos，所以在xml中指定了，在此就不用指定了  
  76.         }  
  77.         //此时就获取到了该请假单的id  
  78.         //通过该leaveId来绑定一个流程实例  
  79.         ProcessInstance processInstance = jbpmTemplate.addProcessInstance("leave",variables, leave.getLeaveId());  
  80.         //该表单到时候是在web页面进行申请时填写好的  
  81.         System.out.println("请假单已填写：" + processInstance.isActive("填写请假单"));  
  82.           
  83.         String taskId = jbpmTemplate.findPersonalTasks("writerForm").get(0).getId();  
  84.         //让任务向下流转,提交任务  
  85.         jbpmTemplate.completeTask(taskId);  
  86.           
  87.     }  
  88.       
  89.     //获取任务集合  
  90.     @Test  
  91.     public void testGetTask(){  
  92.         //经理登陆系统，获取审批任务  
  93.         String username = "胡杰";  
  94.         List<Leave> leaves = new ArrayList<Leave>();//该经理可能对多个请假单审批，该集合提供给页面使用的  
  95.         List<Task> list = jbpmTemplate.findPersonalTasks(username);  
  96.         if(list.size()==0){  
  97.             System.out.println(username + "没有任务.........");  
  98.         }  
  99.         else{  
  100.             for (Task task : list) {  
  101.                 System.out.println("任务名字：" + task.getName());  
  102.                 System.out.println("任务参与者：" + task.getAssignee());  
  103.                 String taskId = task.getId();  
  104.                 String leaveId = (String) jbpmTemplate.getVariableByTaskId(taskId, "leaveId");  
  105.                 Leave leave = leaveDao.findbyIdLeave(leaveId);  
  106.                 leave.setTaskId(taskId);  
  107.                 leaves.add(leave);  
  108.             }  
  109.         }  
  110.           
  111.         //页面显示,并全部通过审批  
  112.         for (Leave leave : leaves) {  
  113.             System.out.println(leave);  
  114.             //批准流程  
  115.             ProcessInstance processInstance = jbpmTemplate.getProcessInstance(leave.getLeaveId());  
  116.             String taskId = leave.getTaskId();  
  117.             int day = leave.getDay();//请假天数  
  118.             if(day>5 && true){//如果大于5天，并且经理批准，也要提交给boos审核  
  119.                 jbpmTemplate.completeTask(taskId, "请假天数>5");  
  120.             }else{//直接通过,既让任务流转到结束  
  121.                 jbpmTemplate.completeTask(taskId,"经理批准");  
  122.             }  
  123.             System.out.println("审批结果：" + processInstance.getState());  
  124.             leave.setStatus("通过");  
  125.             leaveDao.update(leave);//更新结果  
  126.         }  
  127.           
  128.           
  129.     }  
  130.       
  131.     //获取指定用户的请假单集合  
  132.     @Test  
  133.     public void testGetLeave(){  
  134.         //进行业务流转所需的变量  
  135.         String loginName = "cj";//登陆者  
  136.         String password = "cj";//登陆密码  
  137.         User user = userDao.get(loginName,password);  
  138.         //页面显示用  
  139.         List<?> list = leaveDao.findByUserLeave(user.getUserId());  
  140.         for (Object object : list) {  
  141.             System.out.println(object);  
  142.             //是否已经申请  
  143.             //已经提交的请假单不能进行删除操作(所以慎重，呵呵)  
  144.             //新建状态的请假单可以进行删除操作  
  145.         }  
  146.           
  147.     }  
  148.       
  149. }  

web版的我截几个效果图，具体过程你们下载来感受吧:

login.jsp登陆页面http://localhost:90/leave/login.jsp：第一次需要部署一哈



 普通员工登陆用户名和密码为cj:



 经理用户名和密码为hj,登陆后如图：




 
 老板的用户名和密码zxp,进去后如图：


 

 

分享到：
| 【转】正确设置-Dfile.encoding参数
评论
3 楼 beat_it_ 2012-08-02  
lipulvp 写道
能把代码提供一个吗

2 楼 lipulvp 2012-06-08  
能把代码提供一个吗
1 楼 rihongliu 2012-05-14  
刚刚学习JBPM，很有帮助
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics