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

jbpm分页

JBPMSQLHibernateWebworkServlet 
阅读更多
获取jbpm的待办列表，比如用户admin的共有100条待办数据，调用jbpm的API如下：
  1. 获取待办列表：
  2. JbpmContext jbpmContext = JbpmConfiguration.getInstance().createJbpmContext();
  4. TaskMgmtSession taskMgmtSession = jbpmContext.getTaskMgmtSession();
  6. //只能获取尚未完成的任务列表（待办任务）
  7. 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;
  3. /**
  4.  * Created by IntelliJ IDEA.
  5.  * User: yuchen
  6.  * Date: 2008-11-24
  7.  * Time: 17:26:31
  8.  * To change this template use File | Settings | File Templates.
  9.  */
  11. public class Page {
  12.     private int pageSize ;//每页显示的条数
  13.     private int recordCount;//总共的条数
  14.     private int currentPage;//当前页面
  16.     public Page() {
  17.     }
  19.     public Page(int pageSize, int recordCount, int currentPage) {
  20.         this.pageSize = pageSize;
  21.         this.recordCount = recordCount;
  22.         this.setCurrentPage(currentPage,"");
  23.     }
  25.     //构造方法
  26.     public Page(int pageSize, int recordCount) {
  27.         this(pageSize, recordCount, 1);
  28.     }
  30.     //总页数
  31.     public int getPageCount() {
  32.         int size = recordCount / pageSize;//总条数/每页显示的条数=总页数
  33.         int mod = recordCount % pageSize;//最后一页的条数
  34.         if (mod != 0)
  35.             size++;
  36.         return recordCount == 0 ? 1 : size;
  37.     }
  39.     //包含，起始索引为0
  40.     public int getFromIndex() {
  41.         //System.out.println("from index:"+(currentPage-1) * pageSize);
  42.         return (currentPage - 1) * pageSize+1;
  43.     }
  45.     //不包含
  46.     public int getToIndex() {
  47.         //System.out.println("to index:"+Math.min(recordCount, currentPage * pageSize));
  48.         return Math.min(recordCount, currentPage * pageSize);
  49.     }
  51.     //得到当前页
  52.     public int getCurrentPage() {
  53.         return currentPage;
  54.     }//设置当前页
  56.     /**
  57.      *
  58.      * @param currentPage
  59.      * @param inner
  60.      */
  61.     public void setCurrentPage(int currentPage,String inner) {
  62.         int validPage = currentPage <= 0 ? 1 : currentPage;
  63.         validPage = validPage > getPageCount() ? getPageCount() : validPage;
  64.         this.currentPage = validPage;
  65.     }//得到每页显示的条数
  67.     /**
  68.      * 
  69.      * @param currentPage
  70.      */
  71.     public void setCurrentPage(int currentPage) {
  72.         this.currentPage = currentPage;
  73.     }
  74.     //得到每页显示的条数
  75.     public int getPageSize() {
  76.         return pageSize;
  77.     }//设置每页显示的条数
  79.     public void setPageSize(int pageSize) {
  80.         this.pageSize = pageSize;
  81.     }//得到总共的条数
  83.     public int getRecordCount() {
  84.         return recordCount;
  85.     }//设置总共的条数
  87.     public void setRecordCount(int recordCount) {
  88.         this.recordCount = recordCount;
  89.     }
  90. }

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

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

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

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

 

CloseSessionFilter.java

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

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

那么谁来调用

JbpmBaseJdbcDAO .java呢？

 

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

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

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

 

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

JbpmWorklistQueryServiceImpl.java是此接口的实现类

 

 

 

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

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

下面是客户端调用的代码

 

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

 

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

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

  1. package com.mycompany.jbpm.action;
  3. import com.eway.framework.basecomponent.services.jbpm.util.IDeployJbpmProcessService;
  4. import com.eway.framework.basecomponent.services.jbpm.util.Page;
  5. import com.eway.framework.basecomponent.services.jbpm.JbpmProcessDefinitionService;
  6. import com.eway.framework.basecomponent.services.jbpm.JbpmProcessInstanceService;
  7. import com.eway.framework.basecomponent.services.jbpm.JbpmWorklistQueryService;
  8. import com.opensymphony.webwork.ServletActionContext;
  10. import java.util.List;
  12. import org.apache.commons.logging.Log;
  13. import org.apache.commons.logging.LogFactory;
  14. import org.jbpm.taskmgmt.exe.TaskInstance;
  16. import javax.servlet.http.HttpServletRequest;
  17. import javax.servlet.http.HttpServletResponse;
  19. /**
  20.  * Created by IntelliJ IDEA.
  21.  * User: yucehn
  22.  * Date: 2008-11-25
  23.  * Time: 17:20:01
  24.  * To change this template use File | Settings | File Templates.
  25.  */
  26. public class JbpmAction {
  27.     private String processName;
  28.     private IDeployJbpmProcessService ideployJbpmProcessService;//流程发布
  29.     private JbpmProcessDefinitionService jbpmProcessDefinitionService;//流程定义服务
  30.     private Page page = new Page();
  31.     private int currentPageNum;
  32.     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用于任务调度，如考勤管理和工资计算。他在项目中负责系统分析设计、分页组件...

    iuhyiuhkjh908u0980

    28. **分页技术**：PageBean是一种Java中用于实现分页功能的对象，封装了分页的相关信息，如当前页、总页数、每页记录数等，简化了分页逻辑。 这些知识点涵盖了Java开发的多个方面，包括构建工具、框架、数据库、...

    自荐信之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的对象...

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