<!-- jbpm -->      <dependency>                <groupId>org.drools</groupId>                          <artifactId>drools-compiler</artifactId>                          <version>5.4.0.Final</version>                     </dependency>                      <dependency>                               <groupId>org.jbpm</groupId>                               <artifactId>jbpm-bpmn2</artifactId>                               <version>5.4.0.Final</version>                               <exclusions>                     <exclusion>                           <groupId>dom4j</groupId>                           <artifactId>dom4j</artifactId>                     </exclusion>               </exclusions>                     </dependency>                     <dependency>                               <groupId>org.jbpm</groupId>                               <artifactId>jbpm-flow</artifactId>                               <version>5.4.0.Final</version>                               <exclusions>                     <exclusion>                           <groupId>dom4j</groupId>                           <artifactId>dom4j</artifactId>                     </exclusion>               </exclusions>                     </dependency>                     <dependency>                               <groupId>org.jbpm</groupId>                               <artifactId>jbpm-human-task-core</artifactId>                               <version>5.4.0.Final</version>                               <exclusions>                     <exclusion>                           <groupId>dom4j</groupId>                           <artifactId>dom4j</artifactId>                     </exclusion>               </exclusions>                     </dependency>

import java.io.InputStream; import java.io.InputStreamReader; import java.io.Reader; import java.io.Serializable; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Properties; import javax.annotation.PostConstruct; import javax.ejb.LocalBean; import javax.ejb.Stateless; import javax.enterprise.context.ApplicationScoped; import javax.enterprise.inject.Produces; import javax.persistence.EntityManagerFactory; import javax.persistence.PersistenceUnit; import org.drools.KnowledgeBase; import org.drools.SystemEventListenerFactory; import org.drools.builder.KnowledgeBuilder; import org.drools.builder.KnowledgeBuilderFactory; import org.drools.builder.ResourceType; import org.drools.io.Resource; import org.drools.io.ResourceFactory; import org.drools.logger.KnowledgeRuntimeLogger; import org.drools.logger.KnowledgeRuntimeLoggerFactory; import org.drools.runtime.EnvironmentName; import org.drools.runtime.StatefulKnowledgeSession; import org.jbpm.process.workitem.email.EmailWorkItemHandler; import org.jbpm.task.Group; import org.jbpm.task.User; import org.jbpm.task.identity.UserGroupCallbackManager; import org.jbpm.task.service.TaskService; import org.jbpm.task.service.TaskServiceSession; import org.slf4j.Logger; import org.slf4j.LoggerFactory; //import static org.junit.Assert.*; @Stateless @LocalBean public class KnowledgeSessionProducer implements Serializable{           private static final long serialVersionUID = -4494168896880405667L;           private Logger log = LoggerFactory.getLogger(KnowledgeSessionProducer.class);           private KnowledgeRuntimeLogger logger;     @PersistenceUnit(unitName = "org.jbpm.task")     private EntityManagerFactory emf;     public @PostConstruct void init(){               log.debug("init of KnowledgeSessionProducer ...");               TaskService taskService = new TaskService(emf, SystemEventListenerFactory.getSystemEventListener());         TaskServiceSession taskSession = taskService.createSession();         // Add users         @SuppressWarnings("rawtypes")                     Map vars = new HashMap();         InputStream usersin = KnowledgeSessionProducer.class.getResourceAsStream( "/LoadUsers.mvel" );         if(usersin != null) {                   Reader reader = new InputStreamReader( usersin );                     @SuppressWarnings("unchecked")                   Map<String, User> users = ( Map<String, User> ) TaskService.eval( reader, vars );                     log.debug("Users to load in db : ...");                   for ( User user : users.values() ) {                             taskSession.addUser( user );                             log.debug(" - "+user);                   }                   }         InputStream groupsin = KnowledgeSessionProducer.class.getResourceAsStream( "/LoadGroups.mvel" );         if(groupsin != null) {                   Reader reader = new InputStreamReader( groupsin );                     @SuppressWarnings("unchecked")                   Map<String, Group> groups = ( Map<String, Group> ) TaskService.eval( reader, vars );                       log.debug("Groups to load in db : ...");                   for ( Group group : groups.values() ) {                             taskSession.addGroup( group );                             log.debug(" - "+group);                   }         }         // try to get the usergroup callback properties         InputStream usergroupsin = KnowledgeSessionProducer.class.getResourceAsStream(  "/jbpm.usergroup.callback.properties" );         if(usergroupsin != null) {                   Properties callbackproperties = new Properties();                   try {                       // Properties.load(Reader) is a JDK 6 method                             callbackproperties.load(usergroupsin);                             UserGroupCallbackManager.getInstance().setCallbackFromProperties(callbackproperties);                             System.out.println("Task service registered usergroup callback ...");                   } catch (Exception e) {                             System.out.println("Task service unable to register usergroup callback ...");                   }         }         taskSession.dispose();         System.out.println("Task service started correctly!");         System.out.println("Task service running ...");     }           @Produces           @ApplicationScoped           public StatefulKnowledgeSession produceKnowledgeSession(){                     log.debug("produce the KnowledgeSession ...");                     //Create the knowledgeBase                     /*This factory is used to build the knowledge base resources that are held collectively in KnowledgePackages.*/                     KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();                     //Add all processes to the knowledgeBuilder                     List<Resource> resources = getProcessDefinitionList();                     for (Resource resource : resources) {                               kbuilder.add(resource, ResourceType.BPMN2);                     }                     /*Create a new KnowledgeBase from the knowledge packages that have been added to this builder.                      * An exception is thrown if there are any errors.*/ //                    assertFalse( kbuilder.hasErrors() );                     if ( kbuilder.hasErrors() ) {                          log.error( kbuilder.getErrors().toString() );                      }                     KnowledgeBase kbase = kbuilder.newKnowledgeBase();                     /*Create a new StatefulKnowledgeSession using the default session configuration.                      * Don't forget to dispose() session when you are done.                      *                      * StatefulKnowledgeSession is the most common way to interact with the engine.                      * A StatefulKnowledgeSession allows the application to establish an iterative conversation with the engine,                      * where the state of the session is kept across invocations.*/                     StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();         logger = KnowledgeRuntimeLoggerFactory.newThreadedFileLogger(ksession, "loggerFile", 1000);         /*A work item manager is responsible for finding the right work item handler when a work item should be executed          * and should be notified when this work item has been completed (or aborted).          *          * Register the given handler for all work items of the given type of work          * This part is done in the LocalHumanTaskService*/ //        ksession.getWorkItemManager().registerWorkItemHandler("Human Task", handler );         ksession.getEnvironment().set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);         /*          * Register WorkItem Handler for Email          */         //EmailWorkItemHandler emailHandler =  new EmailWorkItemHandler();         //ksession.getWorkItemManager().registerWorkItemHandler("Email", emailHandler);         return ksession;           }           public KnowledgeRuntimeLogger getLogger(){                     return this.logger;           }           private List<Resource> getProcessDefinitionList(){                     List<Resource> resourceList = new ArrayList<>();                     resourceList.add(ResourceFactory.newClassPathResource("workflows/MyFlow.bpmn2"));                     /**                      * TODO                      * add all other process here                      */                     return resourceList;           } }

import javax.annotation.PostConstruct; import javax.enterprise.context.SessionScoped; import javax.enterprise.event.Event; import javax.faces.application.FacesMessage; import javax.faces.context.FacesContext; import javax.inject.Inject; import org.drools.runtime.StatefulKnowledgeSession; import org.jboss.seam.security.Identity; import org.drools.runtime.process.ProcessInstance; import org.jbpm.task.Status; import org.jbpm.task.query.TaskSummary; import org.jbpm.task.service.local.LocalHumanTaskService; import org.jbpm.workflow.instance.WorkflowProcessInstance; import com.st.ams.tools.ClaimEventListener; import com.ste.ws.authentication.seam.api.UserLDAP; /** * Linked to the task management view * */ public @Named @SessionScoped class TaskManager implements Serializable{           private static final long serialVersionUID = 7768657778155604411L;           protected @Inject Identity identity;           private @Inject StatefulKnowledgeSession kSession;           private @Inject Event<ClaimEventListener> event;           private List<Status> listStatus = new ArrayList<Status>();           public org.jbpm.task.TaskService getTaskService(){                     return LocalHumanTaskService.getTaskService(kSession);           }           private List<TaskSummary> userTaskList = new ArrayList<TaskSummary>();           private Map<String, List<TaskSummary>> groupTaskMap = new HashMap<String, List<TaskSummary>>();           private TaskSummary manageTask;           private List<String> groups;           public @PostConstruct void init(){                     System.out.println("init task manager ...");                     //Load user tasks                     listStatus.clear();                     listStatus.add(Status.Reserved);listStatus.add(Status.InProgress);                     System.out.println("load task list for user : "+((UserLDAP)identity.getUser()).getUser().getLogin());                     userTaskList = new ArrayList<TaskSummary>(getTaskService().getTasksAssignedAsPotentialOwnerByStatus(                                                                                 ((UserLDAP)identity.getUser()).getUser().getLogin(),                                                                                 listStatus,                                                                                 "en-UK"));                     //Load groups and tasks for each group                     groups = new ArrayList<String>();                     for(String grp : ((UserLDAP)identity.getUser()).getUser().getGroups()){                  groups.add(grp);                  groupTaskMap.put(grp, getGroupTasks(grp));                     }           }           public List<TaskSummary> getUserTaskList() {                     if((userTaskList == null) || userTaskList.isEmpty()){                               listStatus.clear();                               listStatus.add(Status.Reserved);listStatus.add(Status.InProgress);                //Trick because UserGroupCallBackImpl is not properly implemented                //TODO correction                               Set<TaskSummary> set = new HashSet<TaskSummary>(getTaskService().getTasksAssignedAsPotentialOwnerByStatus(                                                                                                                                                       ((UserLDAP)identity.getUser()).getUser().getLogin(),                                                                                                                                                       listStatus,                                                                                                                                                       "en-UK"));                               userTaskList = new ArrayList<TaskSummary>(set);                     }                     return userTaskList;           }           /**            * In order to refresh the user task list            * This function allow to clear the content of the list            */           public void clearUserTaskList(){                     userTaskList.clear();           }           /**            * In order to refresh the groups task list            * This function allow to clear the content of all lists            */           public void clearAllGroupTaskList(){                     List<String> keys = new ArrayList<>(groupTaskMap.keySet());                     for(String grp : keys){                               clearGroupTaskList(grp);                     }           }           /**            * In order to refresh the group task list            * This function allow to clear the content of the list            */           public void clearGroupTaskList(String group){                     groupTaskMap.put(group, null);           }           /**            * return all group tasks available for the user            * @return List<TaskSummary>            */           public List<TaskSummary> getAllGroupTaskList() {                     List<TaskSummary> allGroupTask = new ArrayList<TaskSummary>();                     Iterable<List<TaskSummary>> mapValues = groupTaskMap.values();                     for(List<TaskSummary> entry : mapValues){                               allGroupTask.addAll(entry);                     }                     return allGroupTask;           }           public List<String> getUserGroups(){                     if((groups == null) || groups.isEmpty()){                               groups = new ArrayList<String>();                               for(String grp : ((UserLDAP)identity.getUser()).getUser().getGroups()){ groups.add(grp);                               }                     }                     return groups;           }           /**            * return tasks available for the group            * @param group            * @return List<TaskSummary>            */           public List<TaskSummary> getGroupTaskList(String group){                     if((groupTaskMap.get(group) == null) || groupTaskMap.get(group).isEmpty()){                               groupTaskMap.put(group, getGroupTasks(group));                     }                     return groupTaskMap.get(group);           }           /**            * return tasks available for the group            * @param group            * @return List<TaskSummary>            */           public List<TaskSummary> getGroupTasks(String group){                     listStatus.clear();                     listStatus.add(Status.Ready);           //Trick because UserGroupCallBackImpl is not properly implemented           //TODO correction           Set<TaskSummary> set = new HashSet<TaskSummary>(getTaskService().getTasksAssignedAsPotentialOwnerByStatus(group, listStatus, "en-UK"));                     return new ArrayList<TaskSummary>(set);           }           public void removeGroup(String group){                     groups.remove(group);           }           public void addGroup(String group){                     if((group != null) && !group.isEmpty())                               groups.add(group);           }           public void addGroupTask(String group){                     groupTaskMap.put(group, getGroupTasks(group));           }           /**            * Start a new processInstance of an existing Process            * and set the variables of this instance            * @param processId, map of variables, id of the requestor            * @return ProcessInstance created            */           public ProcessInstance startProcess(String processId, Map<String, Object> parameters){                     ProcessInstance p = kSession.startProcess(processId,parameters);                     return p;           }           /**            * Return the WorkflowProcessInstance associated to a Task            * This instance allow to access the map of variables            * @return WorkflowProcessInstance managed            */           public WorkflowProcessInstance getWorkflowProcessInstance(long processInstanceId){                     return (WorkflowProcessInstance)kSession.getProcessInstance(processInstanceId);           }           /**            * Start a new processInstance of an existing Process            * @param processId            * @return ProcessInstance created            */           public ProcessInstance startProcess(String processId){                     return kSession.startProcess(processId);           }           /**            * When a user claim a task, the task go to RESERVED state            * Then we call start and the task goes to IN_PROGRESS state            * and is not visible for others            * @param task            */           public void claimTask(TaskSummary task){                     addMessage("task "+task.getId()+" claimed");                     setManageTask(task);                     getTaskService().claim(task.getId(),                                         ((UserLDAP)identity.getUser()).getUser().getLogin());                     getTaskService().start(task.getId(), ((UserLDAP)identity.getUser()).getUser().getLogin());                     event.fire(new ClaimEventListener());           }           /**            * return a task to group task            * @param task            */           public void revokeTask(TaskSummary task){                     addMessage("task "+task.getId()+" revoked");                     setManageTask(task);                     getTaskService().release(task.getId(),                                         ((UserLDAP)identity.getUser()).getUser().getLogin());           }           public void completeTask(TaskSummary task, Object results){                     getTaskService().completeWithResults(task.getId(),                                         ((UserLDAP)identity.getUser()).getUser().getLogin(), results);           }           /**            * The current manage task            * @return TaskSummary            */           public TaskSummary getManageTask() {                     return manageTask;           }           /**            * Set the currently manage task            * (save it during the session)            * @param manageTask            */           private void setManageTask(TaskSummary manageTask) {                     this.manageTask = manageTask;           }           /**            * faces message rendered            * @param message to display            */           public void addMessage(String summary) {          FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, summary,  null);          FacesContext.getCurrentInstance().addMessage(null, message);      } }

jbpm.usergroup.callback=com.your.package.path.with.dot.MyUserGroupCallbackImpl

Sessions can be created based on a knowledge base and are used to execute processes and interact with the engine. You can create as many independent session as you need and creating a session is considered relatively lightweight. How many sessions you create is up to you. In general, most simple cases start out with creating one session that is then called from various places in your application. You could decide to create multiple sessions if for example you want to have multiple independent processing units (for example, if you want all processes from one customer to be completely independent from processes for another customer, you could create an independent session for each customer) or if you need multiple sessions for scalability reasons. If you don't know what to do, simply start by having one knowledge base that contains all your process definitions and create one session that you then use to execute all your processes.