微信登录系列教材（一）- 如何使用 java 开发微信登录教程

微信登录系列教材（二）- 微信开发平台

工具版本兼容问题

步骤 1 : 点击图片进行微信登录测试
步骤 2 : 登录成功

步骤 1 :

点击图片进行微信登录测试

edit 顶折

纠问

点击下面的图片进行微信登录测试

注：只有PC端可以使用，手机浏览器不能使用。

<a target="_blank" href="https://open.weixin.qq.com/connect/qrconnect?appid=wx29859b4928233dd5&redirect_uri=http://how2j.cn/wx.jsp&response_type=code&scope=snsapi_login&state=STATE#wechat_redirect"><img src="https://open.weixin.qq.com/zh_CN/htmledition/res/assets/res-design-download/icon48_wx_button.png"/></a>

源代码

1. 双击选中单词 2. 三击选中整行 3. CTRL+F 查找 4. F8 全屏编辑，再次点击恢复

渲染中渲染完成

效果

步骤 2 :

登录成功

edit 顶折

纠问

登录成功之后，显示如图所示的信息，可以拿到微信用户昵称，头像。更重要的是，拿到授权用户唯一标识 openid.
因为同一个微信用户，扫描某个固定网站的微信登录界面，得到的 openid 都是一样的。所以通过它就可以与与数据库里已经存在的用户数据进行关联了，从而方便后续进行微信登录功能的开发了。

微信登录系列教材（二）- 微信开发平台

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2019-06-17 灭霸的头像相当骚气

编程人青空

关于第三方开发-微信登录-效果演示的提问

站长辛苦啦

8 个答案

yuhan
答案时间：2023-01-09

openId有漏洞了

wzx980804
答案时间：2021-04-15

太强了站长

中工一日游
答案时间：2021-03-10

这个怎么写啊感觉很有意思的样子

aaron123321
答案时间：2020-03-29

微信的统一id是unionid，这个有bug

blue丶梦
答案时间：2020-03-10

代码超过 5行，点击查看

package com.wondersgroup.zjoa.core.service;

import java.sql.Timestamp;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;

import javax.annotation.Resource;

import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import com.wondersgroup.zjoa.core.constant.DocMarks;
import com.wondersgroup.zjoa.core.constant.Globals;
import com.wondersgroup.zjoa.core.constant.Group;
import com.wondersgroup.zjoa.core.constant.WorkFlowNode;
import com.wondersgroup.zjoa.core.constant.Workflow;
import com.wondersgroup.zjoa.core.entity.OaDocAuditUser;
import com.wondersgroup.zjoa.core.entity.OaDocProcessUser;
import com.wondersgroup.zjoa.core.entity.OaDocuments;
import com.wondersgroup.zjoa.core.entity.OaProcess;
import com.wondersgroup.zjoa.core.entity.SystemGroup;
import com.wondersgroup.zjoa.core.entity.doc.OaDocProcessUserEntity;
import com.wondersgroup.zjoa.core.entity.workflow.BaseOaWfHistoryRela;
import com.wondersgroup.zjoa.core.entity.workflow.BaseOaWfInstance;
import com.wondersgroup.zjoa.core.entity.workflow.BaseOaWfProcessUser;
import com.wondersgroup.zjoa.core.entity.workflow.EndWfParams;
import com.wondersgroup.zjoa.core.entity.workflow.NextWfParams;
import com.wondersgroup.zjoa.core.entity.workflow.ProcessUser;
import com.wondersgroup.zjoa.core.entity.workflow.StartWfParams;
import com.wondersgroup.zjoa.core.entity.workflow.WorkflowInfo;
import com.wondersgroup.zjoa.core.form.DocumentForm;
import com.wondersgroup.zjoa.core.form.WfHistoryEntry;
import com.wondersgroup.zjoa.core.form.DocsReceiveProcessForm;
import com.wondersgroup.zjoa.core.repository.OaDocAuditUserRepository;
import com.wondersgroup.zjoa.core.repository.OaDocProcessUserRepository;
import com.wondersgroup.zjoa.core.repository.OaDocumentsRepository;
import com.wondersgroup.zjoa.core.repository.OaProcessRepository;
import com.wondersgroup.zjoa.core.repository.SystemGroupRepository;
import com.wondersgroup.zjoa.core.repository.SystemUserRepository;
import com.wondersgroup.zjoa.core.repository.workflow.BaseOaWfHistoryRelaRepository;
import com.wondersgroup.zjoa.core.repository.workflow.BaseOaWfProcessUserRepository;
import com.wondersgroup.zjoa.core.util.DateUtils;

/**
 * 收文
 * 
 * @author yaozhenzhen 20200227
 *
 */

@Service
public class DocReceiveService {
	@Resource
	private DataDictionaryService dataDictionaryService;
	@Resource
	private SystemUserService systemUserService;
	@Resource
	private SystemGroupService systemGroupService;
	@Resource
	private SystemGroupRepository systemGroupRepository;
	@Resource
	private SystemUserRepository systemUserRepository;
	@Resource
	private OaDocumentsRepository oaDocumentsRepository;

	@Resource
	private OaProcessRepository oaProcessRepository;

	@Resource
	private OaDocAuditUserRepository auditUserRepository;
	@Resource
	private OaDocProcessUserRepository processUserRepository;
	@Resource
	private WorkFlowService workflowService;
	@Resource
	private BaseOaWfHistoryRelaRepository baseOaWfHistoryRelaRepository;
	@Resource
	private BaseOaWfProcessUserRepository baseOaWfProcessUserRepository;
	/**
	 * 初始化收文基本信息 字典项初始化
	 * 
	 * @return documentForm
	 */
	public DocumentForm receiveDocBaseInit() {
		DocumentForm documentForm = new DocumentForm();
		documentForm.setEmergentLevelList(
				dataDictionaryService.getChildrenDataDictionarysByDictCode(Globals.DataDictionary_Code_Documents.JJCD));
		documentForm.setCagegoryList(
				dataDictionaryService.getChildrenDataDictionarysByDictCode(Globals.DataDictionary_Code_Documents.LWLX));
		return documentForm;
	}

	/**
	 * 根据收文ID获取收文的基本信息
	 * 
	 * @param docUuid
	 * @return
	 */
	public OaDocuments findByDocUuid(String docUuid) {
		return oaDocumentsRepository.findTopByDocUuid(docUuid);
	}

	/**
	 * 根据办理Id获取办理详情
	 * 
	 * @param processUuid
	 * @return
	 */
	public OaProcess findByProcessUuid(String processUuid) {
		return oaProcessRepository.findByProcessUuid(processUuid);
	}

	/**
	 * 获取登记办理信息 选择的领导和部门
	 * 
	 * @return
	 */
	public DocsReceiveProcessForm receiveRegisterProcess(String docUuid,String processUuid) {
		DocsReceiveProcessForm processForm = new DocsReceiveProcessForm();
		processForm.setProcessUuid(processUuid);
		// 批示领导下拉框
		processForm.setBanLeaderList(systemUserService.findAllValid());

		// 已保存的处领导（必填项）
		OaDocAuditUser auditUser = auditUserRepository
				.findAuditByDocUuidAndAuditType(docUuid, DocMarks.AuditType.CHULEADER).get(0);
		// 组织id
		processForm.setOwnerGroupId(auditUser.getAuditUserOrganCode());
		// 组织名
		processForm.setOwnerGroupName(systemGroupService.load(auditUser.getAuditUserOrganCode()).getName());
		// 审核处领导userName
		processForm.setLeaderName(auditUser.getAuditUser());
		// 获取当前选中的组织下的审核领导集合（下拉框初始化）
		processForm.setLeaderList(systemUserService.findUserByGroupId(auditUser.getAuditUserOrganCode()));

		// 已保存的领导集合
		processForm.setSelectedAuditUserList(
				auditUserRepository.findAuditUserByDocUuidAndAuditType(docUuid, DocMarks.AuditType.BANLEADER));
		// 已保存的办理部门集合
		List<OaDocProcessUser> processUserList=processUserRepository.findProcessUserListByDocUuid(docUuid);
						
		if(!CollectionUtils.isEmpty(processUserList)) {
			List<OaDocProcessUserEntity> processUserEntityList=toSetProcessUserEntityList(processUserList);
			//选择的办理部门集合			
			processForm.setSelectedOrganList(processUserEntityList);

		}				
		return processForm;                              
	}
	/**
	 * 对办理部门进行封装
	 * @param processUserList
	 * @return
	 */
	private List<OaDocProcessUserEntity> toSetProcessUserEntityList(List<OaDocProcessUser> processUserList){
		List<OaDocProcessUserEntity> processUserEntityList=new ArrayList<OaDocProcessUserEntity>();
		for(OaDocProcessUser processUser:processUserList) {
			OaDocProcessUserEntity processUserEntity=new OaDocProcessUserEntity();
			SystemGroup group=systemGroupRepository.findGroupById(processUser.getUserOrganCode());
			processUserEntity.setDocUuid(processUser.getDocUuid());
			processUserEntity.setProcessUuid(processUser.getProcessUuid());
			processUserEntity.setGroupName(group.getName());
			processUserEntity.setProcessUser(processUser.getProcessUser());
			processUserEntity.setUserOrganCode(processUser.getUserOrganCode());
			processUserEntity.setUserList(systemUserService.findUserByGroupId(processUser.getUserOrganCode()));
			processUserEntityList.add(processUserEntity);
		}
		
		return processUserEntityList;
	}

	/**
	 * 保存基本信息和办理信息
	 * 
	 * @param processForm
	 * @param documentForm
	 * @throws ParseException
	 */
	@Transactional
	public void toSaveProcessInfo(DocsReceiveProcessForm processForm, DocumentForm documentForm, String userName,String userGroupId)
			throws ParseException {
		final String nextUserGroupId=processForm.getOwnerGroupId();
		//根据所选审核人的组织获取
		 // 保存办理部门
		if (processForm.getGroupUserMap().size() > 0) {
			saveProcessUser(processForm.getGroupUserMap(), processForm.getProcessUuid(), processForm.getDocUuid(),
					userName,DocMarks.PROCESS_TYPE);
		}
		// 保存基本信息
		saveOaDocument(documentForm, userName);
		// 保存所属处领导
		List<String> chuLeaderList = new ArrayList<String>();
		chuLeaderList.add(processForm.getLeaderName());
		saveAuditUser(chuLeaderList, processForm.getProcessUuid(), processForm.getDocUuid(), userName,
				DocMarks.AuditType.CHULEADER, processForm.getOwnerGroupId());
		// 保存办（批示）领导
		saveAuditUser(processForm.getToGetAuditUserList(), processForm.getProcessUuid(), processForm.getDocUuid(),
				userName, DocMarks.AuditType.BANLEADER, Group.KCB.getId());

		// 保存办理信息
		saveRegistProcess(processForm, userName);
		// 启动流程
		ProcessUser processUser = new ProcessUser();
		ProcessUser startUser = new ProcessUser();
		processUser.setOrganCode(nextUserGroupId);
		processUser.setLoginName(processForm.getLeaderName());
		startUser.setOrganCode(userGroupId);
		startUser.setLoginName(userName);

		// 启动流程
		startUser.setLoginName(userName);
		Integer wfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE, "0000", // TODO 流水号
				processForm.getDocUuid(), processForm.getProcessUuid(), userGroupId, 
				startUser, userName);                      
		// 提交给负责人审核，需要审核
		if (!CollectionUtils.isEmpty(processForm.getToGetAuditUserList())) {
			nextWf(wfInstanceId, userGroupId, 
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_PROCESS // 需要审核
			);
		} else {
			// 不需要办理，直接到机要归档
			nextWf(wfInstanceId, userGroupId, // 当前组织
					userName, startUser, WorkFlowNode.CONDITION.RECEIVE_NO_PROCESS // 不 需要审核
			);
		}
	}

	/**
	 * 更新退回修改的登记基本信息和办理信息
	 * 
	 * @param processForm
	 * @param documentForm
	 * @throws ParseException
	 */
	@Transactional
	public void toSaveReceive01(DocsReceiveProcessForm processForm, DocumentForm documentForm, String userName,String userGroupId)
			throws ParseException {
		final Integer wfInstanceId = processForm.getWfInstanceId();
		final String nextProcessUserGroupId=processForm.getOwnerGroupId();
		// 更新基本信息
		updateOaDocument(documentForm, userName);
		
		// 保存办理部门
		saveProcessUser(processForm.getGroupUserMap(), processForm.getProcessUuid(), processForm.getDocUuid(),
				userName,DocMarks.PROCESS_TYPE);
		
		// 保存所属处领导
		List<String> chuLeaderList = new ArrayList<String>();
		chuLeaderList.add(processForm.getLeaderName());
		saveAuditUser(chuLeaderList, processForm.getProcessUuid(), processForm.getDocUuid(), userName,
				DocMarks.AuditType.CHULEADER, processForm.getOwnerGroupId());
		
		// 保存领导		
		saveAuditUser(processForm.getToGetAuditUserList(), processForm.getProcessUuid(), processForm.getDocUuid(),
				userName, DocMarks.AuditType.BANLEADER, Group.KCB.getId());// TODO 换成办领导组织ID
		
		// 保存办理信息
		saveRegistProcess(processForm, userName);

		// 推动流程
		ProcessUser processUser = new ProcessUser();
		ProcessUser startUser = new ProcessUser();
		processUser.setOrganCode(nextProcessUserGroupId);
		processUser.setLoginName(processForm.getLeaderName());
		startUser.setOrganCode(userGroupId);
		startUser.setLoginName(userName);
		// 启动流程
		startUser.setLoginName(userName);
		// 提交给负责人审核，需要审核
		if (!CollectionUtils.isEmpty(processForm.getToGetAuditUserList())) {
			nextWf(wfInstanceId, userGroupId, 
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_PROCESS // 需要审核
			);
		} else {
			// 不需要办理，直接到机要归档
			nextWf(wfInstanceId,userGroupId, 
					userName, startUser, WorkFlowNode.CONDITION.RECEIVE_NO_PROCESS //不 需要审核
			);
		}
	}

	/**
	 * 保存基本信息
	 * 
	 * @param documentForm
	 * @param userName
	 * @throws ParseException
	 */
	private void saveOaDocument(DocumentForm documentForm, String userName) throws ParseException {
		OaDocuments oaDoc = new OaDocuments();
		BeanUtils.copyProperties(documentForm, oaDoc);
		Timestamp receiveDate = Timestamp.valueOf(documentForm.getReceiveTime() + " 00:00:00");
		oaDoc.setReceiveDate(receiveDate);
		oaDoc.setDocDiv(Globals.FLG.DOCDIV_RECEIVE);
		oaDoc.setGuanlianLaiwenLeibie("0");// TODO 关联来文
		// oaDoc.setTempSaveFlg(Globals.FLG.YES);// TODO 无暂存
		oaDoc.setCreateId(userName);
		oaDoc.setCreateTime(DateUtils.currentTime());
		oaDoc.setUpdateId(userName);
		oaDoc.setUpdateTime(DateUtils.currentTime());
		oaDoc.setDelFlg(Globals.FLG.YES);// 0：未删除 1：删除
		oaDoc.setFinishFlg(Globals.FLG.YES);// 0:未完成 1：完成
		oaDoc.setSerialNo("90909");// TODO 是否需要
		oaDocumentsRepository.saveAndFlush(oaDoc);
	}

	/**
	 * 更新基本信息
	 * 
	 * @param documentForm
	 * @param userName
	 * @throws ParseException
	 */
	private void updateOaDocument(DocumentForm documentForm, String userName) throws ParseException {
		// 获取原来的基本信息
		OaDocuments oldOaDoc = oaDocumentsRepository.findTopByDocUuid(documentForm.getDocUuid());

		OaDocuments oaDoc = new OaDocuments();
		BeanUtils.copyProperties(documentForm, oaDoc);
		Timestamp receiveDate = Timestamp.valueOf(documentForm.getReceiveTime() + " 00:00:00");
		oaDoc.setReceiveDate(receiveDate);
		oaDoc.setDocDiv(oldOaDoc.getDocDiv());
		oaDoc.setGuanlianLaiwenLeibie(oldOaDoc.getGuanlianLaiwenLeibie());// TODO 关联来文
		// oaDoc.setTempSaveFlg(Globals.FLG.YES);// TODO 无暂存
		oaDoc.setCreateId(oldOaDoc.getCreateId());
		oaDoc.setCreateTime(oldOaDoc.getCreateTime());
		oaDoc.setUpdateId(userName);
		oaDoc.setUpdateTime(DateUtils.currentTime());
		oaDoc.setDelFlg(oldOaDoc.getDelFlg());// 0：未删除 1：删除
		oaDoc.setFinishFlg(oldOaDoc.getFinishFlg());// 0:未完成 1：完成
		oaDoc.setSerialNo(oldOaDoc.getSerialNo());// TODO 是否需要
		oaDocumentsRepository.saveAndFlush(oaDoc);
	}

	/**
	 * 保存登记办理信息
	 * 
	 * @param processForm
	 */
	private void saveRegistProcess(DocsReceiveProcessForm processForm, String userName) {
		// 保存办理信息
		OaProcess oaProcess = new OaProcess();
		BeanUtils.copyProperties(processForm, oaProcess);
		// oaProcess.setTempSaveFlg(Globals.FLG.YES); TODO 删除
		oaProcess.setCreateId(userName);
		oaProcess.setCreateTime(DateUtils.currentTime());
		oaProcess.setUpdateId(userName);
		oaProcess.setUpdateTime(DateUtils.currentTime());
		oaProcess.setDelFlg(Globals.FLG.YES);

		oaProcessRepository.saveAndFlush(oaProcess);
	}

	/**
	 * 保存登记选择的领导
	 * 
	 * @param userList
	 * @param processUuid
	 * @param docUuid
	 * @param userName
	 */
	private void saveAuditUser(List<String> userList, String processUuid, String docUuid, String userName,
			String auditType, String auditUserOrganCode) {
		List<OaDocAuditUser> auditUserList = new ArrayList<OaDocAuditUser>();
		// 先删除原来的数据
		auditUserRepository.deleteAllAuditByDocUuidAndAuditType(docUuid, auditType);
		if (!CollectionUtils.isEmpty(userList)) {
			for (String user : userList) {
				OaDocAuditUser auditUser = new OaDocAuditUser();
				// auditUser.setAuditUuid(UUID.randomUUID().toString());
				auditUser.setDocUuid(docUuid);
				auditUser.setProcessId(processUuid);
				auditUser.setAuditUser(user);
				// auditUser.setSortNo("0");
				auditUser.setAuditType(auditType);
				auditUser.setAuditUserOrganCode(auditUserOrganCode);
				auditUser.setAuditFlg(Globals.FLG.YES);// 0:未审核 1：已审核
				// auditUser.setTempSaveFlg("0");
				auditUser.setCreateId(userName);
				auditUser.setCreateTime(DateUtils.currentTime());
				auditUser.setUpdateId(userName);
				auditUser.setUpdateTime(DateUtils.currentTime());
				auditUser.setDelFlg(Globals.FLG.YES);
				auditUserList.add(auditUser);
			}
			auditUserRepository.saveAll(auditUserList);
		}
	}

	/**
	 * 保存选择的办理部门
	 * 
	 * @param organList
	 * @param processUuid
	 * @param docUuid
	 * @param userName
	 */
	private void saveProcessUser(Map<String, String> groupUserMap, String processUuid, String docUuid,
			String userName,String processType) {
		List<OaDocProcessUser> oaProcessUserList = new ArrayList<OaDocProcessUser>();
		// 先删除原来数据
		processUserRepository.deleteAllByDocUuid(docUuid);
		if (!CollectionUtils.isEmpty(groupUserMap)) {
			for (Entry<String, String> vo : groupUserMap.entrySet()) {
				OaDocProcessUser oaProcessUser = new OaDocProcessUser();

				// oaProcessUser.setProcessUserUuid(UUID.randomUUID().toString());
				oaProcessUser.setDocUuid(docUuid);
				oaProcessUser.setProcessUuid(processUuid);
				oaProcessUser.setProcessType(processType);
				oaProcessUser.setProcessUser(vo.getValue());
				oaProcessUser.setUserOrganCode(vo.getKey());
				oaProcessUser.setCreateId(userName);
				oaProcessUser.setCreateTime(DateUtils.currentTime());
				oaProcessUser.setUpdateId(userName);
				oaProcessUser.setUpdateTime(DateUtils.currentTime());
				oaProcessUser.setDelFlg(Globals.FLG.YES);
				oaProcessUserList.add(oaProcessUser);

			}
			processUserRepository.saveAll(oaProcessUserList);
		}
	}

	/**
	 * 启动流程
	 *
	 * @return 流程实例ID
	 */
	private Integer startWf(String wfKey, String busiEventNo, String busiEventId, String busiProcessId, String nodeCode,
			ProcessUser processUser, String startUserName) {
		StartWfParams startWfParams = new StartWfParams();
		startWfParams.setWfKey(wfKey);
		startWfParams.setBusinessEventNo(busiEventNo);
		startWfParams.setBusinessEventUuid(busiEventId);
		startWfParams.setBusinessProcessUuid(busiProcessId);
		startWfParams.setInputNodeCode(nodeCode);
		startWfParams.setCurrentUser(startUserName);
		startWfParams.addProcessUser(processUser);
		// 获取流程实例id
		WorkflowInfo wf = workflowService.start(startWfParams);
		return wf.getInstanceId();
	}

	/**
	 * next流程
	 *
	 * @param wfInstanceId 流程实例id
	 * @param currentUser  当前登录用户
	 * @param processUser  下一个办理者
	 */
	private void nextWf(Integer wfInstanceId, String inputNodeCode, String currentUser, ProcessUser processUser,
			String nodeCondition) {
		NextWfParams nextWfParams = new NextWfParams();
		nextWfParams.setInstanceId(wfInstanceId); // 流程实例id
		nextWfParams.setInputNodeCode(inputNodeCode);// 当前用户选择组织code
		nextWfParams.setCurrentUser(currentUser); // 当前用户
		nextWfParams.addProcessUser(processUser); // 下一步谁来操作
		nextWfParams.setNodeCondition(nodeCondition);// 节点条件
		workflowService.next(nextWfParams);
	}

	/**
	 * 结束流程
	 * 
	 * @param wfInstanceId
	 * @param currentUser
	 */
	private void endWf(Integer wfInstanceId, String currentUser) {
		EndWfParams endWfParams = new EndWfParams();
		endWfParams.setInstanceId(wfInstanceId);
		endWfParams.setCurrentUser(currentUser);
		workflowService.end(endWfParams);
	}

	/**
	 * 提交处长审核信息
	 * 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveReceiveLdsh01Process(DocsReceiveProcessForm processForm, String userName) {
		final Integer wfInstanceId = processForm.getWfInstanceId();
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		// 推动流程
		ProcessUser processUser = new ProcessUser();
		processUser.setOrganCode("1111");// TODO 获取机要登记人组织
		processUser.setLoginName("admin");// TODO 获取机要登记人
		// 选择同意到机要分发环节
		if(DocMarks.AuditResult.AGREE.equals(processForm.getAuditingResult())) {			
			nextWf(wfInstanceId, "bbb", // TODO 当前组织
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_AGREE // 需要审核
			);
		}else {
			//如果选择不同意，退回到机要登记		
			nextWf(wfInstanceId, "bbb", // TODO 当前组织
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_DISAGREE // 需要审核
			);
		}
	}

	/**
	 * 提交机要分发信息
	 * 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveReceive02Process(DocsReceiveProcessForm processForm, String userName) {
		// 主流程实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		
		// 选择同意到机要分发环节
		// （1）分发部门
		fenFaBuMen(processForm, userName);
		
		//(2)分发领导
		fenFaLeader(processForm, userName);
		//开启等待节点,主流程不能进入任何人的收件箱，所以办理人不能是真实的用户
		//虚假用户,用户表不能查到
		ProcessUser dummyUser = new ProcessUser();
		dummyUser.setOrganCode("##$$%%");
		dummyUser.setLoginName("010101");
		nextWf(wfInstanceId, "bbb", // TODO 当前组织
				userName, dummyUser, null); // 需要审核
	}
	/**
	 * 机要分发部门
	 * @param processForm
	 * @param userName
	 */
	private void fenFaBuMen(DocsReceiveProcessForm processForm,String userName) {
		// 推动流程
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode("bbb");// TODO 获取登录人部门
		startUser.setLoginName(userName);
		List<OaDocProcessUser> processUserList = processUserRepository
				.findProcessUserListByDocUuid(processForm.getDocUuid());
		if(!CollectionUtils.isEmpty(processUserList)) {
		for(OaDocProcessUser proUser:processUserList) {
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(proUser.getUserOrganCode());// 组织 
			processUser.setLoginName(proUser.getProcessUser());// 办理内勤
			//开启新的子流程实例Id 
			Integer childWfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE_PROCESS, "0000", // TODO 流水号
					processForm.getDocUuid(), processForm.getProcessUuid(), "bbb", // TODO 登录用户组织
					startUser, userName);
			nextWf(childWfInstanceId, "bbb", // TODO 当前组织
					userName, processUser, null); // 需要审核
		}
		}
	}
	/**
	 * 机要分发办领导
	 * @param processForm
	 * @param userName
	 */
	private void fenFaLeader(DocsReceiveProcessForm processForm,String userName) {
		// 推动流程
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode("bbb");// TODO 获取登录人部门
		startUser.setLoginName(userName);
		List<String> auditUserList=auditUserRepository.findAuditUserByDocUuidAndAuditType(processForm.getDocUuid(),DocMarks.AuditType.BANLEADER); 
		if(!CollectionUtils.isEmpty(auditUserList)) {
			for(String auditUser:auditUserList) {
				ProcessUser processUser = new ProcessUser();
				processUser.setOrganCode("111");//TODO 获取领导组织 
				processUser.setLoginName(auditUser);// 办理领导
				
				//开启新的子流程领导批示实例Id 
				Integer leaderWfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE_LEADER, "0000", // TODO 流水号
						processForm.getDocUuid(), processForm.getProcessUuid(), "bbb", // TODO 登录用户组织
						startUser, userName);
				nextWf(leaderWfInstanceId, "bbb", // TODO 当前组织
						userName, processUser, null); // 需要审核
				
			}
		}
	}

	/**
	 * 提交机要归档
	 * 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveReceive03Process(DocsReceiveProcessForm processForm, String userName) {
		// 主流程实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		// 结束公文
		finishOaDocument(processForm.getDocUuid(), userName);
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		// 推动流程
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode("bbb");// TODO 获取登录人部门
		startUser.setLoginName(userName);
		// 结束流程
		nextWf(wfInstanceId, "bbb", // TODO 获取登录人部门
				userName, startUser, null);
		endWf(wfInstanceId, userName);
	}

	/**
	 * 结束公文
	 * 
	 * @param documentForm
	 * @param userName
	 * @throws ParseException
	 */
	private void finishOaDocument(String docUuid, String userName) {
		// 获取原来的基本信息
		OaDocuments oaDoc = oaDocumentsRepository.findTopByDocUuid(docUuid);

		oaDoc.setUpdateId(userName);
		oaDoc.setUpdateTime(DateUtils.currentTime());
		oaDoc.setFinishFlg(Globals.FLG.NO);// 0:未完成 1：完成
		oaDoc.setFinishDate(DateUtils.currentTime());
		oaDocumentsRepository.saveAndFlush(oaDoc);
	}
	/**
	 * 保存子流程内勤办理
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcess01Info(DocsReceiveProcessForm processForm, String userName) {
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		
		//分配承办人
		if(processForm.getProcessType().equals(DocMarks.ProcessType.FENPEI_CEHNGBANREN)) {
			fenPeiChengBanRen(processForm, userName);
		}
		//选择审核领导
		if(processForm.getProcessType().equals(DocMarks.ProcessType.LEADER)) {
			songShenLeader(processForm, userName);
		}
	}
	/**
	 * 分发承办人
	 * @param chengBanRenList
	 */
	private void toFenFaChengBanRen(DocsReceiveProcessForm processForm,String organId,String userName) {
		// 推动流程
		//发起人
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(organId);
		startUser.setLoginName(userName);
		
		List<String> chengBanRenList=processForm.getToGetChenBanRenList();
		for(String chengBanRen:chengBanRenList) {
			//办理人
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(organId); 
			processUser.setLoginName(chengBanRen);// 办理领导
			
			//开启新的子流程领导批示实例Id 
			Integer chengBanRenWfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE_PROCESSER, "0000", // TODO 流水号
					processForm.getDocUuid(), processForm.getProcessUuid(), organId, 
					startUser, userName);
			nextWf(chengBanRenWfInstanceId, organId, 
					userName, processUser, null); // 需要审核
		}
				
	}
	/**
	 * 保存子流程的子流程承办人办理
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcess02Info(DocsReceiveProcessForm processForm, String userName) {
		// 子流程的子流流程实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO 获取当前登陆人被选中的组织ID 
		final String groupId="bbb";//processForm.getGroupId();
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		
		// 推动流程
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(groupId);
		startUser.setLoginName(userName);
		// 结束流程
		nextWf(wfInstanceId, groupId,
				userName, startUser, null);
		endWf(wfInstanceId, userName);
		//TODO 获取其他承办人办理未办理完结的实例
		List<BaseOaWfInstance> instanceList=new ArrayList<BaseOaWfInstance>();
		//如果实例全部完结，需要子流程继续进入内勤确认节点
		if(!CollectionUtils.isEmpty(instanceList)) {
			//TODO 获取当前实例id的父实例Id，即对应的二级子流程的实例Id
			Integer secondWfInstanceId=1;
			//TODO 从历史记录里获取内勤
			String neiQin="admin";
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(groupId);
			processUser.setLoginName(neiQin);
			nextWf(secondWfInstanceId, groupId, 
					userName, processUser, null);
		}
	}
	/**
	 * 保存子流程的内勤确认
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcess03Info(DocsReceiveProcessForm processForm, String userName) {		
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		
		//分配承办人
		if(processForm.getProcessType().equals(DocMarks.ProcessType.FENPEI_CEHNGBANREN)) {
			fenPeiChengBanRen(processForm, userName);
		}
		//选择审核领导
		if(processForm.getProcessType().equals(DocMarks.ProcessType.LEADER)) {
			songShenLeader(processForm, userName);
		}
		//办结
		if(processForm.getProcessType().equals(DocMarks.ProcessType.BANJIE)) {
			banJieShenHe(processForm, userName);
		}
	}
	/**
	 * 内勤选择分配承办人
	 * @param processForm
	 * @param userName
	 */
	private void fenPeiChengBanRen(DocsReceiveProcessForm processForm, String userName) {
		// 子流程的子流流程实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO 获取当前登陆人被选中的组织ID 
		final String groupId="bbb";//processForm.getGroupId();
		/***
		 * 使用虚假用户的原因：1、办理人不能为空，2、不能进入真实的人收件箱，3、需要进入下一个环节
		 */
		//虚假用户
		ProcessUser dummyUser = new ProcessUser();
		dummyUser.setOrganCode("##$$%%");
		dummyUser.setLoginName("010101");
		// 驱动流程进入承办人办理
		nextWf(wfInstanceId, groupId, 
				userName, dummyUser, WorkFlowNode.CONDITION.CHENGBANREN_PROCESSER);
		
		if(!CollectionUtils.isEmpty(processForm.getToGetChenBanRenList())) {
			toFenFaChengBanRen(processForm,groupId,userName);
		}
	}
	/**
	 * 内勤选择审核领导办理
	 * @param processForm
	 * @param userName
	 */
	private void songShenLeader(DocsReceiveProcessForm processForm, String userName) {
		// 子流程的子流流程实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO 获取当前登陆人被选中的组织ID 
		final String groupId="bbb";//processForm.getGroupId();
		String leader=processForm.getLeaderName();
		ProcessUser processUser = new ProcessUser();
		processUser.setOrganCode(groupId);
		processUser.setLoginName(leader);
		// 驱动流程进入审核领导办理
		nextWf(wfInstanceId, groupId, 
				userName, processUser, WorkFlowNode.CONDITION.LEADER_PROCESS);
	}
	/**
	 * 内勤确认选择办结
	 * @param processForm
	 * @param userName
	 */
	private void banJieShenHe(DocsReceiveProcessForm processForm, String userName) {
		// 子流程的子流流程实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO 获取当前登陆人被选中的组织ID 
		final String groupId="bbb";//processForm.getGroupId();
		// 推动流程
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(groupId);
		startUser.setLoginName(userName);
		// 结束子流程
		nextWf(wfInstanceId, groupId, 
				userName, startUser, null);
		endWf(wfInstanceId, userName);
		
		//TODO 获取子流程部门未办结的实例Id集合
		List<BaseOaWfInstance> instanceList=new ArrayList<BaseOaWfInstance>();
		//如果实例全部完结为空，需要主流程进入归档节点
		if(CollectionUtils.isEmpty(instanceList)) {
			//TODO 获取当前实例id的父实例Id，即对应的主流程的实例Id
			Integer mainWfInstanceId=1;
			//TODO 从历史记录里获取机要
			String jiYao="admin";
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(groupId);// TODO 获取登录人部门
			processUser.setLoginName(jiYao);
			nextWf(mainWfInstanceId, groupId, // TODO 获取登录人部门
					userName, processUser, null);
		}
	}
	/**
	 * 保存子流程的领导审核
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcessLdsh01Info(DocsReceiveProcessForm processForm, String userName) {
		// 子流程的实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO 获取当前登陆人被选中的组织ID 
		final String groupId="bbb";//processForm.getGroupId();
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		//TODO 获取历史记录里的内勤
		String neiQin="admin";
		
		ProcessUser processUser = new ProcessUser();
		processUser.setOrganCode(groupId);
		processUser.setLoginName(neiQin);
		
		// 驱动流程进入内勤确认
		nextWf(wfInstanceId, groupId, 
				userName, processUser,null);
	}
	/**
	 * 保存办领导批示
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcessComment01Info(DocsReceiveProcessForm processForm, String userName) {
		// 子流程的实例Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO 获取当前登陆人被选中的组织ID 
		final String groupId="bbb";//processForm.getGroupId();
		// 保存办理信息
		saveRegistProcess(processForm, userName);
		
		// 推动流程
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(groupId);
		startUser.setLoginName(userName);
		// 结束子流程
		nextWf(wfInstanceId, groupId, 
				userName, startUser, null);
		endWf(wfInstanceId, userName);
		
		//推动主流程
		//TODO 获取子流程部门未办结的实例Id集合
		List<BaseOaWfInstance> instanceList=new ArrayList<BaseOaWfInstance>();
		//如果实例全部完结为空，需要主流程进入归档节点
		if(CollectionUtils.isEmpty(instanceList)) {
			//TODO 获取当前实例id的父实例Id，即对应的主流程的实例Id
			Integer mainWfInstanceId=1;
			//TODO 从历史记录里获取机要
			String jiYao="admin";
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(groupId);
			processUser.setLoginName(jiYao);
			nextWf(mainWfInstanceId, groupId, // TODO 获取登录人部门
					userName, processUser, null);
		}
				
	}
	/**
	 * 初始化
   * 根据id查询流程路径
   * @param id 流程表id
   * @return 流程路径entry
   */
  public WfHistoryEntry findWfRela(String id) {
    BaseOaWfHistoryRela rela = baseOaWfHistoryRelaRepository.findByBusinessWfUuid(id); 
    BaseOaWfProcessUser processUser = baseOaWfProcessUserRepository.findBybusinessWfUuid(id);
    WfHistoryEntry entry = new WfHistoryEntry();
    entry.setPreProcessUser(rela.getInputUser());   
    entry.setPreGroupId(rela.getInputNodeCode());  
    entry.setCurrentProcessUser(processUser.getProcessOrganCode());    
    entry.setCurrentProcessGroupId(processUser.getProcessOrganCode());  
    entry.setInstanceId(rela.getInstanceId());
    entry.setNodeKey(rela.getNodeKey());
    entry.setBusinessId(rela.getBusinessEventUuid());
    entry.setProcessId(rela.getBusinessProcessUuid());
    return entry;
  } 
}

jesson
答案时间：2019-08-09

辛苦了！

1314zppyh
答案时间：2019-07-22

站长辛苦了，有关于微信公众号的开发信息吗，好想要。。。。。

how2j
答案时间：2019-06-21

是啊，被雷神一刀切了，哈哈哈

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢

关于第三方开发-微信登录-效果演示的提问

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 578362961

提问尽量提供完整的代码，环境描述，越是有利于问题的重现，您的问题越能更快得到解答。
对教程中代码有疑问，请提供是哪个步骤，哪一行有疑问，这样便于快速定位问题，提高问题得到解答的速度
在已经存在的几千个提问里，有相当大的比例，是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本，可以节约自己大量的学习时间。站长把教学中用的软件版本整理了，都统一放在了这里，方便大家下载： https://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图