久伴我还是酒伴我
久伴我还是酒伴我

Activiti（二）

简介

上一章咱们把环境和数据库搞定了，这章就说下怎么新建一个审批模板，怎么部署模板，怎么发起一个审批任务，怎么删除审批模板怎么查看待审批任务列表。

新建审批模板

比如我们需要报销，提交一个申请，然后提交给领导审批，审批完毕后，报销就算结束了。
流程图如下


image.png

设置审批模板属性

package com.glj.activiti.config;

import lombok.extern.log4j.Log4j2;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.activiti.spring.boot.ProcessEngineConfigurationConfigurer;
import org.springframework.stereotype.Component;

@Log4j2
@Component
public class ShareniuProcessEngineConfigurationConfigurer implements ProcessEngineConfigurationConfigurer  {
    public void configure(SpringProcessEngineConfiguration processEngineConfiguration) {
        processEngineConfiguration.setActivityFontName("宋体");
        processEngineConfiguration.setAnnotationFontName("宋体");
        processEngineConfiguration.setActivityFontName("宋体");
        log.info("ShareniuProcessEngineConfigurationConfigurer配置的字体#############"+processEngineConfiguration.getActivityFontName());
    }
}

部署流程

为了使我们的流程被Activiti Engine所知，我们需要部署该流程

package com.glj.activiti.controller;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.glj.activiti.enums.ResponseCode;
import com.glj.activiti.dto.AuditAddUserRequest;
import com.glj.activiti.dto.StartProcessRequest;
import com.glj.activiti.response.JsonResult;
import com.glj.activiti.response.TaskResponse;
import com.glj.activiti.service.IGroupService;
import com.glj.activiti.service.IProcDefService;
import com.glj.activiti.service.IUserService;
import com.glj.activiti.vo.Group;
import com.glj.activiti.vo.User;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.val;
import lombok.extern.slf4j.Slf4j;


@RestController
@Slf4j
@RequestMapping("/taskController")
public class TaskController {
    
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private IUserService userService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IProcDefService procDefService;
    @Autowired
    private IGroupService groupservice;
    
    
     @ApiOperation(value ="部署流程",notes = "添加用户申请的审核处理")
     @PostMapping(value ="/deployProcess") 
    public JsonResult deployProcess(@RequestParam("tenantId") String tenantId, @RequestParam(name="category") String category,
            @RequestParam(name="fileName") String fileName, @RequestPart("file") MultipartFile file) {
        return procDefService.deployProcDef(category, file, tenantId, fileName);
    }
}

部署类型为zip，bar，png，bmmn

@Override
    public JsonResult deployProcDef(String category, MultipartFile file, String tenantId, String fileName) {
        LOGGER.info("deploy(category={}, file={}, tenantId={}, name={})", category, file.getName(), tenantId, fileName);

        InputStream fileInputStream = null;
        JsonResult result = new JsonResult();
        try {
            fileInputStream = file.getInputStream();
        } catch (IOException e) { 
             result.setCode(ResponseCode.ERROR.getValue()).setErrMsg(e.getMessage());
        }
        Deployment deployment = null;
        String basename = FilenameUtils.getBaseName(fileName);
        String extension = FilenameUtils.getExtension(fileName);
        if (extension.equals("zip") || extension.equals("bar")) {
            ZipInputStream zip = new ZipInputStream(fileInputStream);
            deployment = this.repositoryService.createDeployment().name(basename).category(category).tenantId(tenantId)
                    .addZipInputStream(zip).deploy();
        } else if (extension.equals("png")) {
            deployment = this.repositoryService.createDeployment().category(category).tenantId(tenantId).name(file.getName())
                    .addInputStream(fileName, fileInputStream).deploy();
        } else if (fileName.indexOf("bpmn20.xml") != -1) {
            deployment = this.repositoryService.createDeployment().name(basename).category(category).tenantId(tenantId)
                    .addInputStream(fileName, fileInputStream).deploy();
        } else if (extension.equals("bpmn")) { // bpmn扩展名特殊处理，转换为bpmn20.xml
            String baseName = FilenameUtils.getBaseName(fileName);
            deployment = this.repositoryService.createDeployment().name(basename).category(category).tenantId(tenantId)
                    .addInputStream(baseName + ".bpmn20.xml", fileInputStream).deploy();
        } 

        List list = repositoryService.createProcessDefinitionQuery()
                .deploymentId(deployment.getId()).list();

        if (CollectionUtils.isEmpty(list)) {
             result.setCode(ResponseCode.ERROR.getValue()).setErrMsg("流程部署失败");
        }else {
             result.setCode("scucess");
                result.setContent(deployment);
        }

        return result;
    }

部署意味着引擎将解析BPMN流程定义文件并将其转换为可执行文件。此外，还会将记录添加到每个部署的Repository表中。之后，我们可以查询Repository服务从而获取已部署的流程：也就是ProcessDefinitions。

发起任务审批

部署完毕后，就可以发起流程了。

@ApiOperation(value ="发起任务审批",notes = "发起任务审批")
     @PostMapping(value ="/startProcesses") 
    public JsonResult startProcesses(@RequestBody StartProcessRequest request) {
         JsonResult result = new JsonResult();
        try {
            User user = userService.findUserById(request.getId());
            
            Group currentGroup=groupservice.findGroupById(request.getGroupId());
            
            ConcurrentHashMap variables =new ConcurrentHashMap();
            variables.put("userId",user.getId());
            
            String processId= runtimeService.startProcessInstanceByKeyAndTenantId("firstProcess",variables,request.getTenantId()).getId();
            
            String auditMsg = "管理员";
            // 查询到当前发起人的上一级
            List groupList = groupservice.findGroupByType( currentGroup.getType()+1);
            if(groupList!=null&&groupList.size()>0){
                auditMsg= groupList.get(0).getName();
            }
            
            log.info("***************发起审批申请开始***************");
            List tasks = taskService.createTaskQuery().taskAssignee(user.getId()).list();
            log.info("待处理任务数:"+tasks.size());
            for (Task task : tasks) {
                    log.info(user.getId() + "的任务taskname:" + task.getName() + ",id:" + task.getId());
                    taskService.setVariable(task.getId(), "msg", auditMsg);//设置审批类型
                    taskService.complete(task.getId());//完成任务
                    log.info("需要做的下一步审批:" + "审批意见");
            }
            log.info("***************提交添加用户申请完成***************");
            
            
            user.setState(0);
            //修改状态
            user.setAuditState("审核中");
            user.setProcessId(processId);
            
            user = userService.updateState(user);
            
            if(user!=null){
                  result.setCode(ResponseCode.SUCCESS.getValue());
            }else{
                result.setCode(ResponseCode.ERROR.getValue()).setErrMsg("添加用户失败");
            }
        } catch (Exception e) {
             log.error(e.getMessage());
             result.setCode(ResponseCode.ERROR.getValue()).setErrMsg(e.getMessage());
        }
        
        return result;
    }

获取待办任务列表

  @ApiOperation(value ="获取流程待办任务列表",notes = "分页展示流程待办任务基础信息")
        @PostMapping(value ="/todoList}")
        public JsonResult todoList(@RequestBody StartProcessRequest request){
            JsonResult result = new JsonResult();
           
            //取出用户，角色信息
            Group currentGroup=groupservice.findGroupById(request.getGroupId());

            TaskQuery query = taskService.createTaskQuery().taskCandidateGroup(currentGroup.getId());
            
            // 通过人取审批列表
//          query = this.taskService.createTaskQuery().taskAssignee(request.getId()).active()
//                  .includeProcessVariables().orderByTaskCreateTime().desc();
        
            List list =query.list();
            List responses =new ArrayList();
           for (Task task : list) {
               TaskResponse response =new TaskResponse();
               BeanUtils.copyProperties(task,response);
               responses.add(response);
           }
            result.setCode(ResponseCode.SUCCESS.getValue()).setContent(responses);
            return result;
        }

审批人审核任务

@ApiOperation(value ="待办任务处理审核",notes = "添加用户申请的审核处理")
    @PostMapping(value ="/audit/add_user")
    public JsonResult auditAddUser(@RequestBody AuditAddUserRequest auditAddUserRequest) {
        JsonResult result = new JsonResult();
        try {
          
            //首先根据ID查询任务
            Task task=taskService.createTaskQuery() // 创建任务查询
                    .taskId(auditAddUserRequest.getTaskId()) // 根据任务id查询
                    .singleResult();
            Map variables=new HashMap();
            
            // 取用户信息,更新审核状态
            String userId=(String) taskService.getVariable(auditAddUserRequest.getTaskId(), "userId");
            User user=userService.findUserById(userId);
            Group currentGroup=groupservice.findGroupById(user.getGroupIds());
            
            if(auditAddUserRequest.getState()==1){
                user.setAuditState("审核通过");
                user.setState(1);
                variables.put("msg", "通过");
            }else{
                user.setAuditState("审核未通过");
                user.setState(-1);
                variables.put("msg", "未通过");
            }
            // 更新审核信息
            userService.updateState(user);

            // 获取流程实例id
            String processInstanceId=task.getProcessInstanceId();
          
            // 添加批注信息
            taskService.addComment(auditAddUserRequest.getTaskId(), processInstanceId, auditAddUserRequest.getComment());
            
            // 设置用户id
            Authentication.setAuthenticatedUserId(user.getFirst()+user.getLast()+"["+currentGroup.getName()+"]");
            
            // 完成任务
            taskService.complete(auditAddUserRequest.getTaskId(), variables);

            result.setCode(ResponseCode.SUCCESS.getValue());
        }catch (Exception e){
             log.error(e.getMessage());
             result.setCode(ResponseCode.ERROR.getValue()).setErrMsg(e.getMessage());
        }
       
        return result;
    }

删除流程

该流程肯能后期需要添加审批节点或者修改审批规则，需要提前进行删除，然后再次进行部署

 
     @ApiOperation(value ="删除流程",notes = "删除流程")
     @PostMapping(value ="/deleteDeployment") 
    public JsonResult deployProcess(@RequestParam("deploymentId") String deploymentId) {
        return procDefService.deleteDeployment(deploymentId);
    }
     

    
    @Override
    public JsonResult deleteDeployment(String deploymentId) {
        JsonResult result = new JsonResult();
        LOGGER.info("deleteDeployment(deploymentId={})", deploymentId);
        
        Deployment deployment = repositoryService.createDeploymentQuery().deploymentId(deploymentId).singleResult();
        if (deployment == null ) {
            result.setCode(ResponseCode.ERROR.getValue()).setErrMsg("流程部署id:" + deploymentId + " 不存在");
        }else {
            repositoryService.deleteDeployment(deploymentId, true);
            result.setCode(ResponseCode.SUCCESS.getValue()).setContent("流程部署id:" + deploymentId + " 删除成功");
        }
        
        return result;
    }

暂停和激活流程

我们可以暂停ProcessDefinition和ProcessInstance。如果我们暂停一个流程定义ProcessDefinition，则在它暂停挂起时我们就无法创建它的实例。我们可以使用RepositoryService来做到这一点：

@Test(expected = ActivitiException.class)
public void givenDeployedProcess_whenSuspend_thenNoProcessInstance() {
   // deploy the process definition
   repositoryService.suspendProcessDefinitionByKey("vacationRequest");
   runtimeService.startProcessInstanceByKey("vacationRequest");
}
要再次激活它，我们只需要调用其中一个repositoryService.activateProcessDefinitionXXX方法。

同样，我们可以使用RuntimeService暂停ProcessInstance

获取下一个环节列表

@ApiOperation("获取下一环节列表")
    @RequestMapping(value = "/next/list", method = RequestMethod.POST)
    public List nextTask(@RequestBody PvmActivityRequest request) {
        log.info("nextActivity(request={})", request);
        List pvmActivityList = Lists.newArrayList();

        // 根据流程ID获取下一向前的节点
        if (org.apache.commons.lang3.StringUtils.isNotBlank(request.getProcInsId())) {
            // 根据流程实例ID查询任务
            List tasks = taskService.createTaskQuery().processInstanceId(request.getProcInsId()).list();
            
            if (!tasks.isEmpty()) {
                for (Task task : tasks) {
                    // 根据当前任务获取当前流程的流程定义，然后根据流程定义获得所有的节点：
                    ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) this.repositoryService)
                            .getDeployedProcessDefinition(task.getProcessDefinitionId());
                    List activitiList = processDefinition.getActivities();
                    // 根据任务获取当前流程执行ID，执行实例以及当前流程节点的ID：
                    Execution execution = this.runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();//根据ID获取执行器
                    String activitiId = execution.getActivityId();
                    // 循环activitiList 并判断出当前流程所处节点，然后得到当前节点实例，根据节点实例获取所有从当前节点出发的路径，然后根据路径获得下一个节点实例：
                    if (!activitiList.isEmpty()) {
                        for (ActivityImpl activityImpl : activitiList) {
                            if (activitiId.equals(activityImpl.getId())) {
                                List outTransitions = activityImpl.getOutgoingTransitions();// 获取从某个节点出来的所有线路
                                recursiveSelect(pvmActivityList, outTransitions,
                                        ArrayUtils.toArray(ProcessConstant.ACTIVITY_TYPE_USERTASK, ProcessConstant.ACTIVITY_TYPE_ENDEVENT));
                                break;
                            }
                        }
                    }
                }
            }
        } else if (org.apache.commons.lang3.StringUtils.isNotBlank(request.getTenantId()) && org.apache.commons.lang3.StringUtils.isNotBlank(request.getProcDefKey())) {
            // 根据tenantId和流程定义key查找开始用户节点
            ProcessDefinition processDefinition = this.repositoryQuery
                    .getLatestProcDefByKeyAndTenantId(request.getProcDefKey(), request.getTenantId());
            if (processDefinition != null) {
                ProcessDefinitionEntity processDefinitionEntity = this.repositoryQuery
                        .getProcDefEntity(processDefinition.getId());
                List activitiList = processDefinitionEntity.getActivities();
                if (activitiList.isEmpty()) {
                    // 找到开始节点
                    ActivityImpl startEvent = null;
                    for (ActivityImpl activityImpl : activitiList) {
                        if (ProcessConstant.ACTIVITY_TYPE_STARTEVENT.equalsIgnoreCase(
                                activityImpl.getProperty("type").toString())) {
                            startEvent = activityImpl;
                            break;
                        }
                    }

                    // 找到开始节点后的第一个用户节点
                    if (startEvent != null) {
                        List outTransitions = startEvent.getOutgoingTransitions();// 获取从某个节点出来的所有线路
                        recursiveSelect(pvmActivityList, outTransitions,
                                ProcessConstant.ACTIVITY_TYPE_USERTASK);
                    }
                }
            }
        }

        List list = Lists.newArrayList();
        if (!pvmActivityList.isEmpty()) {
            list = pvmActivityList.stream().map(activityFunction).collect(Collectors.toList());
        }

        return list;
    }
    
    
    
    /**
         * 递归获取指定类型的节点
     *
     * @param pvmActivityList
     * @param outTransitions
     * @param types
     * @return
     */
    public static List recursiveSelect(List pvmActivityList,
                                                    List outTransitions, String... types) {
        if (!outTransitions.isEmpty()) {
            for (PvmTransition pvmTransition : outTransitions) {
                // 根据流程线的condition过滤驳回的环节，如果包含back则跳过指向流程
                Object conditionText = pvmTransition.getProperty("conditionText");
                if (conditionText != null
                        && conditionText.toString().equalsIgnoreCase(ProcessConstant.TASK_STATUS_BACK)) {
                    continue;
                }

                PvmActivity pvmActivity = pvmTransition.getDestination();
                Object typeObj = pvmActivity.getProperty("type");
                if (typeObj != null) {
                    if (ArrayUtils.contains(types, typeObj.toString())) {
                        pvmActivityList.add(pvmActivity);
                    } else {
                        recursiveSelect(pvmActivityList, pvmActivity.getOutgoingTransitions(), types);
                    }
                }
            }
        }
        return pvmActivityList;
    }

获取下一环节用户列表

 /**
     * 获取下一环节用户列表
     * @param request
     * @return
     */
  
    public List listUserByActId(ActivityUserRequest request) {
        log.info("listUserByActId(request={})", request);
        final List response = Lists.newArrayList();

        ProcessDefinition processDefinition = this.repositoryQuery.getProcDefById(request.getProcDefId());
        Preconditions.checkNotNull(processDefinition,"流程定义ID【" + request.getProcDefId() + "】不存在");

        ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) this.repositoryService)
                .getDeployedProcessDefinition(processDefinition.getId());
        List activitiList = processDefinitionEntity.getActivities();

        if (!activitiList.isEmpty()) {
            List filterList = activitiList.stream()
                    .filter(activity -> request.getActivityId().equals(activity.getId()))
                    .collect(Collectors.toList());

            
            Preconditions.checkNotNull(filterList,"节点ID【" + request.getActivityId() + "】不存在");

            ActivityImpl activity = filterList.get(0);
            ActivityBehavior activityBehavior = activity.getActivityBehavior();
            // 检查是否用户任务
            boolean result = activityBehavior instanceof UserTaskActivityBehavior;
            if (!result) {
                 throw new NullPointerException(String.valueOf("节点ID【\" + request.getActivityId() + \"】非用户任务"));
            }
            
            UserTaskActivityBehavior utaBehavior = (UserTaskActivityBehavior) activityBehavior;
            TaskDefinition taskDefinition = ((UserTaskActivityBehavior) utaBehavior).getTaskDefinition();

            // 获取候选用户ID表达式列表
            Set userIds = taskDefinition.getCandidateUserIdExpressions();
            if (!userIds.isEmpty()) {
                List users = userIds.stream().map(userId -> {
                    return userId.getExpressionText();
                }).collect(Collectors.toList());

                // 添加指定用户ID列表的用户
                response.addAll(users.stream().map(userInfo->{
                    UserResponse user = new UserResponse();
                    user.setUserId(userInfo);
                    return user;
                }).collect(Collectors.toList()));

                // 添加指定流程变量表达式的用户
                if (org.apache.commons.lang3.StringUtils.isNotBlank(request.getProcInsId())) {
                    users.forEach(user -> {
                        // 流程启动人变量
                        if (user.equals(ProcessConstant.PROCESS_VARIABLES_START_USER_ID)) {
                            String userId = this.runtimeQuery.getProcessStartUser(request.getProcInsId());
                            if (org.apache.commons.lang3.StringUtils.isNotBlank(userId)) {
                                UserResponse user1 = new UserResponse();
                                user1.setUserId(userId);
                                response.add(user1);
                                
                            }
                        }
                    });
                }
            }

            // 获取候选组ID列表
            Set groupIds = taskDefinition.getCandidateGroupIdExpressions();
            if (!groupIds.isEmpty()) {
                List groups = groupIds.stream().map(groupId -> {
                    return groupId.getExpressionText();
                }).collect(Collectors.toList());
                // 查找所有该组的用户
                groups.forEach(group -> {
                    GroupUserQueryRequest queryRequest = new GroupUserQueryRequest(request.getTenantId(), group);
                    
                    //response.addAll(this.identityManager.listUserByGroup(queryRequest));
                });

            }
        }

        return response;
    }

获取流程图图片

/**
     * 流程定义Key
     * 流程实例ID
     * 租户主键
     * 获取流程图图片
     * @param request
     * @return
     */
    
    public InputStream tracePhoto(TraceRequest request) {
        log.info("tracePhoto(request={})", request);
        ProcessDefinition processDefinition = this.checkProcDef(request.getProcDefKey(), request.getTenantId());

        List activeActivityIds = Lists.newArrayList();
        if (this.runtimeService.createExecutionQuery().executionId(request.getProcInsId()).count() > 0) {
            activeActivityIds = runtimeService.getActiveActivityIds(request.getProcInsId());
        }

        Context.setProcessEngineConfiguration(this.processEngine.getProcessEngineConfiguration());

        BpmnModel bpmnModel = this.repositoryService.getBpmnModel(processDefinition.getId());
        return new DefaultProcessDiagramGenerator().generateDiagram(bpmnModel, "png", activeActivityIds,
                Collections.emptyList(), this.processEngine.getProcessEngineConfiguration().getActivityFontName(),
                this.processEngine.getProcessEngineConfiguration().getLabelFontName(),
                this.processEngine.getProcessEngineConfiguration().getAnnotationFontName(), null, 1.0);
    }
    /* 检查流程定义 */
    private ProcessDefinition checkProcDef(String procDefKey, String tenantId) {
        ProcessDefinition processDefinition = this.repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey(procDefKey).processDefinitionTenantId(tenantId).latestVersion().active().singleResult();
        if (processDefinition == null) {
             throw new NullPointerException(String.valueOf("流程定义Key:"+ procDefKey + " 不存在"));
        }
        
        return processDefinition;
    }

获取审批意见列表

/**
     * 获取审批意见列表
     * @param procInsId
     * @return
     */
    @Override
    public List listComment(String procInsId) {
        log.info("listComment(procInsId={})", procInsId);

        List responseList = Lists.newArrayList();
        List comments = this.taskService.getProcessInstanceComments(procInsId,
                ProcessConstant.COMMENT_TYPE_COMMENT);
        if (!comments.isEmpty()) {
            comments.forEach(comment -> {
                CommentResponse commentResponse = new CommentResponse();
                CommentEntity commentEntity = (CommentEntity) comment;
                BeanUtils.copyProperties(commentEntity, commentResponse);

                // 没有任务ID则为启动流程，默认状态为true(同意)
                if (org.apache.commons.lang3.StringUtils.isNotBlank(comment.getTaskId())) {
                    
                    HistoricTaskInstance historicTaskInstance = this.historyService.createHistoricTaskInstanceQuery().processInstanceId(procInsId)
                            .taskId(comment.getTaskId()).includeProcessVariables().includeTaskLocalVariables()
                            .finished().singleResult();
                    
                    if (historicTaskInstance != null) {
                        // 有任务ID，则判断任务状态
                        String status = historicTaskInstance.getTaskLocalVariables().get(ProcessConstant.TASK_VARIABLES_DEAL_STATU).toString();
                                
                        if (ProcessConstant.TASK_STATUS_BACK.equals(status)) {
                            commentResponse.setStatus(false);
                        }

                        // 设置任务名称
                        commentResponse.setTaskName(historicTaskInstance.getName());
                    }
                }
                responseList.add(commentResponse);
            });
        }

        // 按最新审批时间排序
        if (!responseList.isEmpty()) {
            Collections.sort(responseList, Comparator.comparing(CommentResponse::getTime).reversed());
        }

        // 获取当前处理人 和 当前节点
        ProcessInstance processInstance = this.runtimeQuery.getActiveProcInst(procInsId);
        if (processInstance != null) {
            CommentResponse commentResponse = new CommentResponse();
            commentResponse.setUserId(ObjectUtils.nullSafeToString(
                    processInstance.getProcessVariables().get(ProcessConstant.PROCESS_VARIABLES_CLAIM)));
            //全局变量 map
            ProcessDefinitionCache.setRepositoryService(repositoryService);
            commentResponse.setTaskName(ProcessDefinitionCache.getActivityName(processInstance.getProcessDefinitionId(),
                    processInstance.getActivityId()));
            commentResponse.setStatus(null);
            responseList.add(0, commentResponse);
        }

        return responseList;
    }

结束语

到目前位置，Activiti主要的功能已经完成的差不多了,后面还有一些激活流程，或者将流程模板挂起，后续再补充上。

你可能感兴趣的:(Activiti（二）)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 2022-07-08 保利学府里李楚怡1307022
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
  • 直抒《紫罗兰永恒花园外传》 雷姆的黑色童话
    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 如果做到轻松在股市赚钱？只要坚持这三个原则。 履霜之人
    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 特殊的拜年 飘雪的天堂
    文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
  • 398顺境，逆境 戴骁勇
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
  • 想明白这个问题，你才能写下去 文自拾
    春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • 其二 十八尾喵
    你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • webpack图片等资源的处理 dmengmeng
    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 如何成为段子手 欣雅阅读
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 主题升华随机抽总结 木棉咕噜
    昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • 这个世界为何对女性这么苛刻 遇见知见
    图片发自App当今社会的女性，简直用金刚侠来形容都不为过。虽然早已过了男尊女卑的时代，但是这个世界并没有平等的对待女性。新时代的女性标准：上得了厅堂，下得了厨房，杀得了木马，翻得了围墙，开得起好车，买得起新房，斗得过二奶，打得过流氓，生得了孩子，养得了家庭。这个社会对女性有太多的不公平，既要求女性经济独立，又要求女性贤良淑德。所有的女性的在成长过程中没有任何一项是因为你是女性而给你开绿灯的。图片发
  • 日常演播练习0822 开阳春天
    日常演播练习0822一、绕口令练习司小四和史小世，四月十四日十四时四十上集市，司小四买了四十四斤四两西红柿，史小世买了十四斤四两细蚕丝。司小四要拿四十四斤四两西红柿换史小世十四斤四两细蚕丝。史小世十四斤四两细蚕丝不换司小四四十四斤四两西红柿。司小四说我四十四斤四两西红柿可以增加营养防近视，史小世说我十四斤四两细蚕丝可以织绸织缎又抽丝。二、文本练习狗熊是动物街有名的美食家，它吃得多所以长得胖，它能吃
  • 数据采集高并发的架构应用 3golden .net
    问题的出发点：          最近公司为了发展需要，要扩大对用户的信息采集，每个用户的采集量估计约2W。如果用户量增加的话，将会大量照成采集量成3W倍的增长，但是又要满足日常业务需要，特别是指令要及时得到响应的频率次数远大于预期。       &n
  • 不停止 MySQL 服务增加从库的两种方式 brotherlamp linuxlinux视频linux资料linux教程linux自学
    现在生产环境MySQL数据库是一主一从，由于业务量访问不断增大，故再增加一台从库。前提是不能影响线上业务使用，也就是说不能重启MySQL服务，为了避免出现其他情况，选择在网站访问量低峰期时间段操作。  一般在线增加从库有两种方式，一种是通过mysqldump备份主库，恢复到从库，mysqldump是逻辑备份，数据量大时，备份速度会很慢，锁表的时间也会很长。另一种是通过xtrabacku
  • Quartz——SimpleTrigger触发器 eksliang SimpleTriggerTriggerUtilsquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208166 一.概述 SimpleTrigger触发器，当且仅需触发一次或者以固定时间间隔周期触发执行；   二.SimpleTrigger的构造函数 SimpleTrigger(String name, String group)：通过该构造函数指定Trigger所属组和名称； Simpl
  • Informatica应用（1） 18289753290 sqlworkflowlookup组件Informatica
    1.如果要在workflow中调用shell脚本有一个command组件，在里面设置shell的路径；调度wf可以右键出现schedule，现在用的是HP的tidal调度wf的执行。 2.designer里面的router类似于SSIS中的broadcast（多播组件）;Reset_Workflow_Var：参数重置 （比如说我这个参数初始是1在workflow跑得过程中变成了3我要在结束时还要
  • python 获取图片验证码中文字 酷的飞上天空 python
    根据现成的开源项目 http://code.google.com/p/pytesser/改写 在window上用easy_install安装不上  看了下源码发现代码很少  于是就想自己改写一下   添加支持网络图片的直接解析   #coding:utf-8 #import sys #reload(sys) #sys.s
  • AJAX 永夜-极光 Ajax
    1.AJAX功能:动态更新页面,减少流量消耗,减轻服务器负担   2.代码结构:    <html> <head> <script type="text/javascript"> function loadXMLDoc() { .... AJAX script goes here ...
  • 创业OR读研 随便小屋 创业
            现在研一，有种想创业的想法，不知道该不该去实施。因为对于的我情况这两者是矛盾的，可能就是鱼与熊掌不能兼得。                研一的生活刚刚过去两个月，我们学校主要的是
  • 需求做得好与坏直接关系着程序员生活质量 aijuans IT 生活
            这个故事还得从去年换工作的事情说起，由于自己不太喜欢第一家公司的环境我选择了换一份工作。去年九月份我入职现在的这家公司，专门从事金融业内软件的开发。十一月份我们整个项目组前往北京做现场开发，从此苦逼的日子开始了。        系统背景：五月份就有同事前往甲方了解需求一直到6月份，后续几个月也完
  • 如何定义和区分高级软件开发工程师 aoyouzi
    在软件开发领域，高级开发工程师通常是指那些编写代码超过 3 年的人。这些人可能会被放到领导的位置，但经常会产生非常糟糕的结果。Matt Briggs 是一名高级开发工程师兼 Scrum 管理员。他认为，单纯使用年限来划分开发人员存在问题，两个同样具有 10 年开发经验的开发人员可能大不相同。近日，他发表了一篇博文，根据开发者所能发挥的作用划分软件开发工程师的成长阶段。 　　初
  • Servlet的请求与响应 百合不是茶 servletget提交java处理post提交
      Servlet是tomcat中的一个重要组成,也是负责客户端和服务端的中介     1,Http的请求方式(get  ,post);   客户端的请求一般都会都是Servlet来接受的,在接收之前怎么来确定是那种方式提交的,以及如何反馈,Servlet中有相应的方法,  http的get方式 servlet就是都doGet(
  • web.xml配置详解之listener bijian1013 javaweb.xmllistener
    一.定义 <listener> <listen-class>com.myapp.MyListener</listen-class> </listener>   二.作用        该元素用来注册一个监听器类。可以收到事件什么时候发生以及用什么作为响
  • Web页面性能优化（yahoo技术） Bill_chen JavaScriptAjaxWebcssYahoo
    1.尽可能的减少HTTP请求数 content 2.使用CDN server 3.添加Expires头(或者 Cache-control) server 4.Gzip 组件 server 5.把CSS样式放在页面的上方。 css 6.将脚本放在底部(包括内联的) javascript 7.避免在CSS中使用Expressions css 8.将javascript和css独立成外部文
  • 【MongoDB学习笔记八】MongoDB游标、分页查询、查询结果排序 bit1129 mongodb
    游标   游标，简单的说就是一个查询结果的指针。游标作为数据库的一个对象，使用它是包括 声明 打开 循环抓去一定数目的文档直到结果集中的所有文档已经抓取完 关闭游标   游标的基本用法，类似于JDBC的ResultSet(hasNext判断是否抓去完,next移动游标到下一条文档)，在获取一个文档集时，可以提供一个类似JDBC的FetchSize
  • ORA-12514 TNS 监听程序当前无法识别连接描述符中请求服务 的解决方法 白糖_ ORA-12514
    今天通过Oracle SQL*Plus连接远端服务器的时候提示“监听程序当前无法识别连接描述符中请求服务”，遂在网上找到了解决方案： ①打开Oracle服务器安装目录\NETWORK\ADMIN\listener.ora文件，你会看到如下信息：   # listener.ora Network Configuration File: D:\database\Oracle\net
  • Eclipse 问题 A resource exists with a different case bozch eclipse
    在使用Eclipse进行开发的时候，出现了如下的问题： Description Resource Path Location TypeThe project was not built due to "A resource exists with a different case: '/SeenTaoImp_zhV2/bin/seentao'.&
  • 编程之美-小飞的电梯调度算法 bylijinnan 编程之美
    public class AptElevator { /** * 编程之美 小飞 电梯调度算法 * 在繁忙的时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。 * 所有乘客都从一楼上电梯，到达某层楼后，电梯听下来，所有乘客再从这里爬楼梯到自己的目的层。 * 在一楼时，每个乘客选择自己的目的层，电梯则自动计算出应停的楼层。 * 问：电梯停在哪
  • SQL注入相关概念 chenbowen00 sqlWeb安全
    SQL Injection：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。 具体来说，它是利用现有应用程序，将（恶意）的SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 首先让我们了解什么时候可能发生SQ
  • [光与电]光子信号战防御原理 comsci 原理
          无论是在战场上,还是在后方,敌人都有可能用光子信号对人体进行控制和攻击,那么采取什么样的防御方法,最简单,最有效呢?       我们这里有几个山寨的办法,可能有些作用,大家如果有兴趣可以去实验一下       根据光
  • oracle 11g新特性:Pending Statistics daizj oracledbms_stats
    oracle 11g新特性:Pending Statistics 转 从11g开始，表与索引的统计信息收集完毕后，可以选择收集的统信息立即发布，也可以选择使新收集的统计信息处于pending状态，待确定处于pending状态的统计信息是安全的，再使处于pending状态的统计信息发布，这样就会避免一些因为收集统计信息立即发布而导致SQL执行计划走错的灾难。 在 11g 之前的版本中，D
  • 快速理解RequireJs dengkane jqueryrequirejs
    RequireJs已经流行很久了，我们在项目中也打算使用它。它提供了以下功能： 声明不同js文件之间的依赖 可以按需、并行、延时载入js库 可以让我们的代码以模块化的方式组织 初看起来并不复杂。 在html中引入requirejs 在HTML中，添加这样的 <script> 标签： <script src="/path/to
  • C语言学习四流程控制if条件选择、for循环和强制类型转换 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i, j; scanf("%d %d", &i, &j); if (i > j) printf("i大于j\n"); else printf("i小于j\n"); retu
  • dictionary的使用要注意 dcj3sjt126com IO
    NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: user.user_id , @"id", user.username , @"username",
  • Android 中的资源访问(Resource) finally_m xmlandroidStringdrawablecolor
    简单的说，Android中的资源是指非代码部分。例如，在我们的Android程序中要使用一些图片来设置界面，要使用一些音频文件来设置铃声，要使用一些动画来显示特效，要使用一些字符串来显示提示信息。那么，这些图片、音频、动画和字符串等叫做Android中的资源文件。 在Eclipse创建的工程中，我们可以看到res和assets两个文件夹，是用来保存资源文件的，在assets中保存的一般是原生
  • Spring使用Cache、整合Ehcache 234390216 springcacheehcache@Cacheable
    Spring使用Cache            从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的
  • 当druid遇上oracle blob(clob) jackyrong oracle
    http://blog.csdn.net/renfufei/article/details/44887371 众所周知，Oracle有很多坑, 所以才有了去IOE。 在使用Druid做数据库连接池后，其实偶尔也会碰到小坑，这就是使用开源项目所必须去填平的。【如果使用不开源的产品，那就不是坑，而是陷阱了，你都不知道怎么去填坑】 用Druid连接池，通过JDBC往Oracle数据库的
  • easyui datagrid pagination获得分页页码、总页数等信息 ldzyz007
    var grid = $('#datagrid');  var options = grid.datagrid('getPager').data("pagination").options;  var curr = options.pageNumber;  var total = options.total;  var max =
  • 浅析awk里的数组 nigelzeng 二维数组array数组awk
    awk绝对是文本处理中的神器，它本身也是一门编程语言，还有许多功能本人没有使用到。这篇文章就单单针对awk里的数组来进行讨论，如何利用数组来帮助完成文本分析。   有这么一组数据：   abcd,91#31#2012-12-31 11:24:00 case_a,136#19#2012-12-31 11:24:00 case_a,136#23#2012-12-31 1
  • 搭建 CentOS 6 服务器(6) - TigerVNC rensanning centos
    安装GNOME桌面环境 # yum groupinstall "X Window System" "Desktop" 安装TigerVNC # yum -y install tigervnc-server tigervnc 启动VNC服务 # /etc/init.d/vncserver restart # vncser
  • Spring 数据库连接整理 tomcat_oracle springbeanjdbc
    1、数据库连接jdbc.properties配置详解 　　jdbc.url=jdbc:hsqldb:hsql://localhost/xdb 　　jdbc.username=sa 　　jdbc.password= 　　jdbc.driver=不同的数据库厂商驱动，此处不一一列举 　　接下来，详细配置代码如下： 　　 Spring连接池    
  • Dom4J解析使用xpath java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常 xp9802
    用Dom4J解析xml,以前没注意,今天使用dom4j包解析xml时在xpath使用处报错      异常栈：java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常       导入包 jaxen-1.1-beta-6.jar 解决; &nb
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他