`
madrocket
  • 浏览: 17380 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

jbpm分页

阅读更多
获取jbpm的待办列表,比如用户admin的共有100条待办数据,调用jbpm的API如下:
  1. 获取待办列表:
  2. JbpmContext jbpmContext = JbpmConfiguration.getInstance().createJbpmContext();
  3. TaskMgmtSession taskMgmtSession = jbpmContext.getTaskMgmtSession();
  4. //只能获取尚未完成的任务列表(待办任务)
  5. List list = taskMgmtSession.findTaskInstances(userId);

下面的jbpm的源码

 

  1.   public List findTaskInstances(String actorId) {
  2.     List result = null;
  3.     try {
  4.       Query query = session.getNamedQuery("TaskMgmtSession.findTaskInstancesByActorId");
  5.       query.setString("actorId", actorId);
  6.       result = query.list();
  7.     } catch (Exception e) {
  8.       log.error(e);
  9.       jbpmSession.handleException();
  10.       throw new JbpmException("couldn't get task instances list for actor '"+actorId+"'", e);
  11.     }
  12.     return result;
  13.   }

TaskMgmtSession.findTaskInstancesByActorId所对应的sql语句如下:

  1. <query name="TaskMgmtSession.findTaskInstancesByActorId">
  2.     <![CDATA[
  3.       select ti
  4.       from org.jbpm.taskmgmt.exe.TaskInstance as ti
  5.       where ti.actorId = :actorId
  6.         and ti.isOpen = true
  7.     ]]>
  8.   </query>

可以看到jbpm并没有实现分页的处理

仅仅是把所有的记录都查询出来了

所以下面,进行了封装,实现了分页。

 

首先建立Page.java

 

 

 

  1. package com.eway.framework.basecomponent.services.jbpm.util;
  2. /**
  3.  * Created by IntelliJ IDEA.
  4.  * User: yuchen
  5.  * Date: 2008-11-24
  6.  * Time: 17:26:31
  7.  * To change this template use File | Settings | File Templates.
  8.  */
  9. public class Page {
  10.     private int pageSize ;//每页显示的条数
  11.     private int recordCount;//总共的条数
  12.     private int currentPage;//当前页面
  13.     public Page() {
  14.     }
  15.     public Page(int pageSize, int recordCount, int currentPage) {
  16.         this.pageSize = pageSize;
  17.         this.recordCount = recordCount;
  18.         this.setCurrentPage(currentPage,"");
  19.     }
  20.     //构造方法
  21.     public Page(int pageSize, int recordCount) {
  22.         this(pageSize, recordCount, 1);
  23.     }
  24.     //总页数
  25.     public int getPageCount() {
  26.         int size = recordCount / pageSize;//总条数/每页显示的条数=总页数
  27.         int mod = recordCount % pageSize;//最后一页的条数
  28.         if (mod != 0)
  29.             size++;
  30.         return recordCount == 0 ? 1 : size;
  31.     }
  32.     //包含,起始索引为0
  33.     public int getFromIndex() {
  34.         //System.out.println("from index:"+(currentPage-1) * pageSize);
  35.         return (currentPage - 1) * pageSize+1;
  36.     }
  37.     //不包含
  38.     public int getToIndex() {
  39.         //System.out.println("to index:"+Math.min(recordCount, currentPage * pageSize));
  40.         return Math.min(recordCount, currentPage * pageSize);
  41.     }
  42.     //得到当前页
  43.     public int getCurrentPage() {
  44.         return currentPage;
  45.     }//设置当前页
  46.     /**
  47.      *
  48.      * @param currentPage
  49.      * @param inner
  50.      */
  51.     public void setCurrentPage(int currentPage,String inner) {
  52.         int validPage = currentPage <= 0 ? 1 : currentPage;
  53.         validPage = validPage > getPageCount() ? getPageCount() : validPage;
  54.         this.currentPage = validPage;
  55.     }//得到每页显示的条数
  56.     /**
  57.      * 
  58.      * @param currentPage
  59.      */
  60.     public void setCurrentPage(int currentPage) {
  61.         this.currentPage = currentPage;
  62.     }
  63.     //得到每页显示的条数
  64.     public int getPageSize() {
  65.         return pageSize;
  66.     }//设置每页显示的条数
  67.     public void setPageSize(int pageSize) {
  68.         this.pageSize = pageSize;
  69.     }//得到总共的条数
  70.     public int getRecordCount() {
  71.         return recordCount;
  72.     }//设置总共的条数
  73.     public void setRecordCount(int recordCount) {
  74.         this.recordCount = recordCount;
  75.     }
  76. }

为了统一管理hibernate的session,笔者写了HibernateUtil.java

  1. package com.eway.framework.basecomponent.services.jbpm.util;
  2. import org.hibernate.HibernateException;
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.Transaction;
  6. import org.hibernate.cfg.Configuration;
  7. /**
  8.  * Created by IntelliJ IDEA.
  9.  * User: yuchen
  10.  * Date: 2008-11-26
  11.  * Time: 12:23:03
  12.  * To change this template use File | Settings | File Templates.
  13.  */
  14. //定义一个HibernateUtil类来初始化hinernate 创建SessionFactory实例,并提供创建Session实例,关闭Session实例
  15. //以及打开/关闭事务  和从新创建SessionFactory实例的使用方法(所以方法都为静态)
  16. public class HibernateUtil {
  17.     private static final SessionFactory sessionFactory;
  18.     static {
  19.         try {
  20.             sessionFactory = new Configuration().configure().buildSessionFactory();
  21.         } catch (Throwable ex) {
  22.             ex.printStackTrace();
  23.             throw new ExceptionInInitializerError(ex);
  24.         }
  25.     }
  26.     public static final ThreadLocal<Session> tLocalsess = new ThreadLocal<Session>();
  27.     public static final ThreadLocal<Transaction> tLocaltx = new ThreadLocal<Transaction>();
  28.     /*
  29.       getting the thread-safe session for using  取得session
  30.     */
  31.     public static Session currentSession() {
  32.         Session session = (Session) tLocalsess.get();
  33.         try {
  34.             if (session == null || !session.isOpen()) {
  35.                 session = openSession();
  36.                 tLocalsess.set(session);
  37.             }
  38.            System.out.println("session.isOpen()===="+session.isOpen());
  39.         } catch (HibernateException e) {
  40.             e.printStackTrace();
  41.         }
  42.         return session;
  43.     }
  44.     /*
  45.     * closing the thread-safe session 关闭session
  46.     */
  47.     public static void closeSession() {
  48.         Session session = (Session) tLocalsess.get();
  49.         tLocalsess.set(null);
  50.         try {
  51.             if (session != null && session.isOpen()) {
  52.                 session.close();
  53.             }
  54.         } catch (HibernateException e) {
  55.         }
  56.     }
  57.     /*
  58.     * begin the transaction 开始事务
  59.     */
  60.     public static void beginTransaction() {
  61.         Transaction tx = (Transaction) tLocaltx.get();
  62.         try {
  63.             if (tx == null) {
  64.                 tx = currentSession().beginTransaction();
  65.                 tLocaltx.set(tx);
  66.             }
  67.         } catch (HibernateException e) {
  68.         }
  69.     }
  70.     // close the transaction 关闭事务
  71.     public static void commitTransaction() {
  72.         Transaction tx = (Transaction) tLocaltx.get();
  73.         try {
  74.             if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
  75.                 tx.commit();
  76.             tLocaltx.set(null);
  77.         } catch (HibernateException e) {
  78.         }
  79.     }
  80. //  for rollbacking 事务回滚
  81.     public static void rollbackTransaction() {
  82.         Transaction tx = (Transaction) tLocaltx.get();
  83.         try {
  84.             tLocaltx.set(null);
  85.             if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
  86.                 tx.rollback();
  87.             }
  88.         } catch (HibernateException e) {
  89.         }
  90.     }
  91.     private static Session openSession() throws HibernateException {
  92.         return getSessionFactory().openSession();
  93.     }
  94.     private static SessionFactory getSessionFactory() throws HibernateException {
  95.         return sessionFactory;
  96.     }
  97. }

用于获取hibernate的session和事务处理,同时写了一个filter类,用于关闭session

笔者用的web服务器是tomcat,采用webwork+spring+hibernate+jbpm(如果你不是这样的,也具体不影响什么)

 

CloseSessionFilter.java

  1. package com.eway.framework.basecomponent.services.jbpm.util;
  2. import java.io.IOException;
  3. import javax.servlet.Filter;
  4. import javax.servlet.FilterChain;
  5. import javax.servlet.FilterConfig;
  6. import javax.servlet.ServletException;
  7. import javax.servlet.ServletRequest;
  8. import javax.servlet.ServletResponse;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import org.apache.commons.logging.Log;
  12. import org.apache.commons.logging.LogFactory;
  13. /**
  14.  * Created by IntelliJ IDEA.
  15.  * User: yuchen
  16.  * Date: 2008-11-26
  17.  * Time: 13:10:04
  18.  * To change this template use File | Settings | File Templates.
  19.  */
  20. public class CloseSessionFilter implements Filter {
  21.     Log log = LogFactory.getLog(this.getClass());
  22.     protected FilterConfig config;
  23.     public void init(FilterConfig config) throws ServletException {
  24.         this.config = config;
  25.     }
  26.     public void doFilter(
  27.             ServletRequest request,
  28.             ServletResponse response,
  29.             FilterChain chain)
  30.             throws IOException, ServletException {
  31.         try {
  32.             chain.doFilter((HttpServletRequest) request, (HttpServletResponse) response);
  33.         }
  34.         finally {
  35.             try {
  36.                 HibernateUtil.closeSession();
  37.                 log.debug("close session success");
  38.             }
  39.             catch (Exception e) {
  40.                 HibernateUtil.rollbackTransaction();
  41.                 log.debug("can not close session!\nerrors:" + e.getMessage());
  42.             }
  43.             finally {
  44.                 HibernateUtil.closeSession();
  45.             }
  46.         }
  47.     }
  48.     public void destroy() {
  49.     }
  50. }

这个需要在web.xml中配置一下

 

  1. <filter> 
  2.         <filter-name>closeHibernateSessionFilter</filter-name> 
  3.         <filter-class>com.eway.framework.basecomponent.services.jbpm.util.CloseSessionFilter</filter-class
  4.     </filter> 
  5.     <filter-mapping> 
  6.         <filter-name>closeHibernateSessionFilter</filter-name> 
  7.         <url-pattern>/jbpm/*</url-pattern>
  8.     </filter-mapping> 
 
JbpmBaseJdbcDAO .java负责处理查询,根据传来的sql,page,和参数进行查询,并返回查询结果
 
  1. package com.eway.framework.basecomponent.services.jbpm.util;
  2. import org.hibernate.Session;
  3. import org.hibernate.Query;
  4. import org.hibernate.HibernateException;
  5. import org.apache.commons.logging.Log;
  6. import org.apache.commons.logging.LogFactory;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.HashMap;
  10. /**
  11.  * Created by IntelliJ IDEA.
  12.  * User: yuchen
  13.  * Date: 2008-11-24
  14.  * Time: 17:26:16
  15.  * To change this template use File | Settings | File Templates.
  16.  */
  17. public class JbpmBaseJdbcDAO {
  18.     private Page page;
  19.     private Session hibernateSession;
  20.     /**
  21.      * 默认构造器
  22.      */
  23.     public JbpmBaseJdbcDAO() {
  24.         this.page = null;
  25.         this.hibernateSession = HibernateUtil.currentSession(); //当前的hibernate会话
  26.     }
  27.     /**
  28.      * 带参构造器
  29.      *
  30.      * @param pageSize
  31.      * @param currentPage
  32.      * @param recordCount
  33.      */
  34.     public JbpmBaseJdbcDAO(int pageSize, int currentPage, int recordCount) {
  35.         page = new Page();
  36.         page.setRecordCount(recordCount);
  37.         page.setCurrentPage(currentPage);
  38.         page.setPageSize(pageSize);
  39.         this.hibernateSession = HibernateUtil.currentSession(); //当前的hibernate会话
  40.     }
  41.     /**
  42.      * @param page
  43.      */
  44.     public JbpmBaseJdbcDAO(Page page) {
  45.         this.page = page;
  46.     }
  47.     /*
  48.     * 根据sql,参数查询出结果
  49.     * @param sql
  50.     * @param parameterMap
  51.     * @return
  52.     */
  53.     public List<Object> findByOutQuery(String sql, Map<String, Object> parameterMap) {
  54.         Query query = null;
  55.         List list = null;
  56.         try {
  57.             log.info("hibernateSession.isOpen()====" + hibernateSession.isOpen());
  58.             boolean issql = sql.indexOf("from") != -1;//sql中包含字符串 “from”
  59.             if (issql)
  60.                 query = hibernateSession.createQuery(sql);        //查询对象
  61.             else
  62.                 query = hibernateSession.getNamedQuery(sql);        //查询对象
  63.             if (this.page != null) {
  64.                 page.setRecordCount(this.getTotalCount(sql, parameterMap));
  65.                 int pageSize = page.getPageSize();//每页显示的条数
  66.                 int firstResult = page.getFromIndex();//从第多少条记录开始查询
  67.                 if (pageSize > 0 && firstResult > 0) {
  68.                     query.setFirstResult(firstResult);
  69.                     query.setMaxResults(pageSize);
  70.                 }
  71.             }
  72.             parameterMap = parameterMap == null ? new HashMap() : parameterMap;
  73.             for (String key : parameterMap.keySet()) {      //对查询条件进行迭代
  74.                 if (key != null && !"".equals(key)) {
  75.                     Object value = parameterMap.get(key);
  76.                     if (value != null) {
  77.                         query.setParameter(key, value);     //加入查询条件
  78.                     }
  79.                 }
  80.             }
  81.             list = query.list();
  82.         } catch (HibernateException e) {
  83.             log.error("method--[findByOutQuery] throws HibernateException" + e.getMessage());
  84.             e.printStackTrace();
  85.         }
  86.         return list;
  87.     }
  88.     /**
  89.      * 根据sql,参数和页码查询出结果
  90.      *
  91.      * @param sql
  92.      * @param parameterMap
  93.      * @param page
  94.      * @return
  95.      */
  96.     public List<Object> findByOutQuery(String sql, Map<String, Object> parameterMap, Page page) {
  97.         this.page = page;
  98.         return this.findByOutQuery(sql, parameterMap);
  99.     }
  100.     /**
  101.      * 根据sql,参数和页码查询出结果
  102.      *
  103.      * @param sql
  104.      * @param parameterMap
  105.      * @param pageSize
  106.      * @param currentPage
  107.      * @param recordCount
  108.      * @return
  109.      */
  110.     public List<Object> findByOutQueryAndPage(String sql, Map<String, Object> parameterMap, int pageSize, int currentPage, int recordCount) {
  111.         page = new Page();
  112.         page.setRecordCount(recordCount);
  113.         page.setCurrentPage(currentPage);
  114.         page.setPageSize(pageSize);
  115.         return this.findByOutQuery(sql, parameterMap);
  116.     }
  117.     /**
  118.      * 取到总共的条数
  119.      *
  120.      * @param sql
  121.      * @param parameterMap
  122.      * @return
  123.      */
  124.     private Integer getTotalCount(String sql, Map<String, Object> parameterMap) {
  125.         Integer  amount = 0;
  126.         Query query = null;
  127.         try {
  128.             boolean issql = sql.indexOf("from") != -1;//sql中包含字符串 “from”
  129.             if (!issql) {
  130.                 query = hibernateSession.getNamedQuery(sql);
  131.                 sql = query.getQueryString();
  132.             }
  133.             int sql_index = sql.indexOf(" from");
  134.             String countStr = "select count(*) " + sql.substring(sql_index);
  135.             query = hibernateSession.createQuery(countStr);        //查询对象
  136.             parameterMap = parameterMap == null ? new HashMap() : parameterMap;
  137.             for (String key : parameterMap.keySet()) {      //对查询条件进行迭代
  138.                 if (key != null && !"".equals(key)) {
  139.                     Object value = parameterMap.get(key);
  140.                     if (value != null) {
  141.                         query.setParameter(key, value);     //加入查询条件
  142.                     }
  143.                 }
  144.             }
  145.             List list = query.list();
  146.             if (!list.isEmpty()) {
  147.                 Object count    =   list.get(0);
  148.                  amount   =    Integer.parseInt(count.toString());
  149.             }
  150.         } catch (HibernateException e) {
  151.             log.error("method--[getTotalCount] throws HibernateException" + e.getMessage());
  152.             e.printStackTrace();
  153.         }
  154.         return amount;
  155.     }
  156.     private static Log log = LogFactory.getLog(JbpmBaseJdbcDAO.class);
  157.     //getter and setter method
  158.     public Page getPage() {
  159.         return page;
  160.     }
  161.     public void setPage(Page page) {
  162.         this.page = page;
  163.     }
  164. }

那么谁来调用

JbpmBaseJdbcDAO .java呢?

 

有下面的接口提供给用户使用

  1. package com.eway.framework.basecomponent.services.jbpm;
  2. import com.eway.framework.basecomponent.services.jbpm.util.Page;
  3. import java.util.Collection;
  4. import java.util.List;
  5. /**
  6.  * Created by IntelliJ IDEA.
  7.  * Author: xinpeng
  8.  * Date: 2008-10-21
  9.  * Time: 11:08:14
  10.  * To change this template use File | Settings | File Templates.
  11.  */
  12. public interface JbpmWorklistQueryService {
  13.     public Collection<TaskInstanceDTO> queryToSignInListByPage(String userId,Page page);
  14.     public List queryTodoListByPage(String userId, Page page);
  15.     public Collection<TaskInstanceDTO> queryCompletedListByPage(String userId, Page page);
  16. }

可以看到方法public List queryTodoListByPage(String userId, Page page);正是我们所需要的

 

根据参与者和page对象可以取到当前参与者的对应page的待办列表

JbpmWorklistQueryServiceImpl.java是此接口的实现类

 

 

 

  1. package com.eway.framework.basecomponent.services.jbpm;
  2. import org.apache.commons.logging.Log;
  3. import org.apache.commons.logging.LogFactory;
  4. import java.math.BigDecimal;
  5. import java.util.*;
  6. import com.eway.framework.basecomponent.services.jbpm.util.Page;
  7. import com.eway.framework.basecomponent.services.jbpm.util.JbpmBaseJdbcDAO;
  8. /**
  9.  * Created by IntelliJ IDEA.
  10.  * Author: xinpeng
  11.  * Date: 2008-10-21
  12.  * Time: 11:08:37
  13.  * To change this template use File | Settings | File Templates.
  14.  */
  15. public class JbpmWorklistQueryServiceImpl implements JbpmWorklistQueryService {
  16.     private static final Log log = LogFactory.getLog(JbpmWorklistQueryServiceImpl.class);
  17.     public Collection<TaskInstanceDTO> queryToSignInListByPage(String userId, Page page) {
  18.         //todo:改为分页的实现
  19.         Collection<TaskInstanceDTO> todoList = new ArrayList<TaskInstanceDTO>();
  20.         return todoList;
  21.     }
  22.     /**
  23.      * 取到待办列表
  24.      */
  25.     public List queryTodoListByPage(String userId, Page page) {
  26.         List todoList = new ArrayList();
  27.         String sqlPath = "TaskMgmtSession.findTaskInstancesByActorId";
  28.         JbpmBaseJdbcDAO baseJdbcDao = new JbpmBaseJdbcDAO();
  29.         Map paraMap = new HashMap();
  30.         paraMap.put("actorId""admin");
  31.         todoList = baseJdbcDao.findByOutQuery(sqlPath, paraMap, page);
  32. //
  33. //        String sql = "select * from JBPM_TASKINSTANCE a where a.actorId_=? and a.isSuspended_ = ? and a.isOpen_ = ? and a.start_ is not null order by a.START_ desc";
  34. //        Object[] args = new Object[]{userId, false, true};
  35. //        List lstResultMap = baseJdbcDAO.findByOutQuery(sql, args);
  36. //        for (Object mapItem : lstResultMap) {
  37. //            Map map = (Map) mapItem;
  38. //            String name = (String) map.get("NAME_");
  39. //            log.debug("name = " + name);
  40. //            TaskInstanceDTO taskInstance = new TaskInstanceDTO();
  41. //            BigDecimal big = (BigDecimal) map.get("ID_");
  42. //            taskInstance.setId(big.longValue());
  43. //            taskInstance.setName(name);
  44. //            taskInstance.setActorId((String) map.get("ACTORID_"));
  45. //            taskInstance.setStart((Date) map.get("START_"));
  46. //            taskInstance.setTokenId(((BigDecimal) map.get("TOKEN_")).longValue());
  47. //            taskInstance.setTaskId(((BigDecimal) map.get("TASK_")).longValue());
  48. //            taskInstance.setTaskMgmtInstanceId(((BigDecimal) map.get("TASKMGMTINSTANCE_")).longValue());
  49. //            //taskInstance.setSwimlaneInstanceId(((BigDecimal)map.get("SWIMLANINSTANCE_")).longValue());
  50. //            todoList.add(taskInstance);
  51. //        }
  52. //        log.info("todoList==" + todoList);
  53.         return todoList;
  54.     }
  55.     /**
  56.      * 取到办结列表
  57.      * @param userId
  58.      * @param page
  59.      * @return
  60.      */
  61.     public Collection<TaskInstanceDTO> queryCompletedListByPage(String userId, Page page) {
  62.         //todo:改为分页的实现
  63.         JbpmBaseJdbcDAO jbpmBaseJdbcDAO = new JbpmBaseJdbcDAO();
  64.         Collection<TaskInstanceDTO> completedList = new ArrayList<TaskInstanceDTO>();
  65.         return completedList;
  66.     }
  67. }

这样在客户端,,对此接口的方法进行调用就可以分页了。。

下面是客户端调用的代码

 

当然也是用webwork的一个action进行访问

 

webwork的具体配置就省去了,相信大家已经很熟悉了

JbpmAction.java中的获取待办列表的方法todoList 对待办列表进行了调用。

  1. package com.mycompany.jbpm.action;
  2. import com.eway.framework.basecomponent.services.jbpm.util.IDeployJbpmProcessService;
  3. import com.eway.framework.basecomponent.services.jbpm.util.Page;
  4. import com.eway.framework.basecomponent.services.jbpm.JbpmProcessDefinitionService;
  5. import com.eway.framework.basecomponent.services.jbpm.JbpmProcessInstanceService;
  6. import com.eway.framework.basecomponent.services.jbpm.JbpmWorklistQueryService;
  7. import com.opensymphony.webwork.ServletActionContext;
  8. import java.util.List;
  9. import org.apache.commons.logging.Log;
  10. import org.apache.commons.logging.LogFactory;
  11. import org.jbpm.taskmgmt.exe.TaskInstance;
  12. import javax.servlet.http.HttpServletRequest;
  13. import javax.servlet.http.HttpServletResponse;
  14. /**
  15.  * Created by IntelliJ IDEA.
  16.  * User: yucehn
  17.  * Date: 2008-11-25
  18.  * Time: 17:20:01
  19.  * To change this template use File | Settings | File Templates.
  20.  */
  21. public class JbpmAction {
  22.     private String processName;
  23.     private IDeployJbpmProcessService ideployJbpmProcessService;//流程发布
  24.     private JbpmProcessDefinitionService jbpmProcessDefinitionService;//流程定义服务
  25.     private Page page = new Page();
  26.     private int currentPageNum;
  27.     private List jbpmProcessDefinitionList;   

分享到:
评论
1 楼 皇室勇少 2010-01-22  
认真的看过。但是对于业务数据过多的话。我还是选择另外设计业务表。 在jbpm表中记录关健字段。

相关推荐

    jbpm与OA项目(六).pdf

    【jbpm与OA项目(六).pdf】...综上所述,该文档详细介绍了在Web开发中实现分页功能的方法,并预告了对JBPM审批流程管理的学习路径。理解并掌握这两个知识点,将有助于开发者在实际项目中构建更高效、用户友好的系统。

    JBPM、OSWORKFLOW分析报告

    2. **分页问题**:基于第1个问题的解决方案,可以在自定义的Hibernate查询基础上实现分页功能。 3. **统计流程实例状态**:可以通过查询JBPM系统表中的流程实例来统计各个流程实例的状态。另一种方法是在业务表中...

    jbpm的实现流程图.doc

    遗憾的是,由于提供的文本中包含的特殊字符和分页信息,无法直接解读具体的流程图细节,但以上概述了jbpm实现的核心概念和流程,希望能帮助理解jbpm的工作原理。对于更详细的流程图分析,建议参考原始的doc文档。

    Java软件开发工程师简历.pdf

    同时,该工程师还实现了分页优化、JBPM 工作流引入和自定义标签设计等功能。 在迅达商贸管理系统中,该工程师主要负责开发基于 Struts2、Spring、Hibernate 的系统,实现了快速高效协作和异地网上办公。

    MyOA(办公自动化系统)

    传智播客的OA系统(改写版),使用Struts2,spring,hibernate,jbpm整合,系统包含了三大模块,分别是:系统管理,站内消息,审批流转。系统管理中还包含了权限分配,其中有很多技术点,比如,jquery的页面验证,强大的...

    Java工程师个人求职简历(全文).docx

    他还利用ThreadLocal实现页面分页,JSTL和自定义函数处理JSP页面,DWR处理授权,JBPM实现工作流程,Freemarker进行动态表单设计,Quartz用于任务调度,如考勤管理和工资计算。他在项目中负责系统分析设计、分页组件...

    自荐信之java软件开发简历模板.docx

    例如,Web OA系统使用了MyEclipse、Oracle和Tomcat,结合Struts+Hibernate+Spring架构,使用ThreadLocal实现分页,JSTL和自定义函数处理JSP页面,DWR进行授权,JBPM实现公文流转,Quartz处理任务调度,Freemarker...

    java软件开发简历模板.docx

    求职者在此项目中负责DAO模式和工厂模式的设计,以及分页组件、流向单维护等模块的开发,使用了JSP + JavaBean架构,并应用Ajax技术。 - **基于小波分解的数字图像水印嵌入和提取**:这是科研性质的项目,求职者...

    java工程师的个人简历(九篇).docx

    - 在多个项目中,工程师展现了其在实际应用中的技能,例如使用Struts+Hibernate+Spring的多层架构,对ThreadLocal模式、JSTL、DWR、JBPM、Freemarker、Quartz等技术的掌握,这体现了他在企业级应用开发中的实战经验...

    java程序员面试简历&#40;列子&#41;.doc.doc

    - DaoSupport用于通用的DAO操作,封装分页功能,并使用自定义泛型。 - 文件上传下载通过IO和特定库如JSPSmartUpload、Spring的POI实现。 这份简历展示了应聘者扎实的Java Web开发基础,丰富的框架使用经验以及...

    参考简历_2.doc

    数据库 Redis、服务器 Nginx、分布式系统 Hadoop、SSH2 框架、MySql、Sqlserver、Oracle、Eclipse/MyEclipse、SVN、CVS、VSS、Java 基础技术 Jsp、Servlet、Jdbc、JavaScript、Ajax、JQuery、JBPM、PowerDesigner、...

    (完整word)Java软件开发工程师简历.doc

    1. 实现了分页优化,利用面向对象原则提高了代码复用性和可读性。 2. 引入了JBPM工作流引擎,提升了物流配送流程的效率,实现自动化流程控制。 3. 设计了自定义标签,根据角色权限动态生成页面菜单,增强了权限管理...

    (完整word)Java软件开发工程师简历.docx

    8. **设计原则与模式**:在分页功能的设计中,遵循面向对象的五大原则,实现了接口抽象,提高了代码的复用性和可读性。此外,使用自定义标签和权限管理模型,展示了灵活应对业务需求的能力。 9. **权限与安全**:...

    JavaEE学习实战笔记心得

    - **分页技巧**:了解如何在Servlet、Hibernate和Spring等不同技术栈中实现分页功能。 - **错误处理**:处理常见的404、500错误,并自定义错误页面。 #### 前端技术心得 - **动画效果**:使用CSS3动画或JavaScript...

    java开发程序员简历

    * 使用 Hibernate 实现持久化层,使用泛型 DAO 封装添/删/改/查/分页/统计这些操作 * 实现细粒度权限管理使用 Struts2 中提供的拦截器实现对 Action 方法的拦截 * 粗粒度权限管理使用 Filter 实现 * 使用 Java、...

    Java项目公共模块提取

    在Java项目中,公共模块的提取可以使用Struts、Spring、Hibernate、JBPM、Ajax、JSP等技术。这些技术可以帮助开发者快速构建项目,并提供了许多有用的功能,例如Struts的MVC框架、Spring的依赖注入、Hibernate的对象...

Global site tag (gtag.js) - Google Analytics