实现微信订阅号强制关注

最新推荐文章于 2022-11-19 21:43:31 发布
最新推荐文章于 2022-11-19 21:43:31 发布
阅读量2.2w 收藏 26
点赞数 1
分类专栏： 移动HTML5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyyaries/article/details/52020573
版权

众所周知，微信订阅号是没有网页授权接口权限的，因此不可以直接判断用户的关注状态，但并不意味没有其他方法可以实现，下面就是一种还不错的方法。

首先你需要一个服务号，并通过微信认证，然后在微信开放平台http://open.weixin.qq.com注册一个帐号，将你的服务号和订阅号都绑定到开放平台，绑定后如下图：


绑定后，订阅号和服务号将通过unionid关联用户信息，也就是说同个openid调用服务号拉取用户信息接口和订阅号获取用户信息接口都将返回相同的unionid

具体实现步骤和原理：

1.同步订阅号用户列表和用户信息（如果您的订阅号已经在运营），保存到数据库表（包括unionid、关注状态等）

2.用服务号做网页授权，拉取用户信息，获取unionid

3.根据unionid在数据表查询用户关注状态

4.开发订阅号事件接口，通过取消关注事件更新数据表用户关注状态


同步订阅号用户列表和用户信息代码

@RequestMapping(value="/syncOpenid")
	@ResponseBody
	public String syncWxOpenid(final HttpServletRequest request){
		if(WeixinUtil.syncOpenidStatus){
			return JSON.toJSONString(new DwzAjaxResult("300", "同步已在进行", "", "", ""));
		}
		final WxToken token = wxTokenService.getWxTokenByKey(WX_TOKEN_KEY.NORMAL_ACCESS_TOKEN.getKey());
		if(token == null || !token.isActive() || token.getToken_value() == null || "".equals(token.getToken_value())){
			return JSON.toJSONString(new DwzAjaxResult("300", "获取AccessToken失败", "", "", ""));
		}
		//标识Openid已经在同步状态
		WeixinUtil.syncOpenidStatus = true;
		//获取最后一个Openid，从最后一个开始
		//final WxOpenid lastOpenid = wxOpenidService.getLatestOpenid();
		Runnable orun = new Runnable() {
			private String nextOpenId;
			private WxToken tk;
			private boolean flag = true;
			@Override
			public void run() {
				if(tk == null){
					//初始化token
					tk = token;
				}
//				if(nextOpenId == null && lastOpenid != null && lastOpenid.getOpen_id() != null){
//					nextOpenId = lastOpenid.getOpen_id();
//				}
				System.out.println("= Sync openid start =");
				while(flag){
					//调用微信用户列表接口
					try {
						JSONObject jo = getUserList(nextOpenId);
						if(jo != null && !jo.containsKey("errcode")){
							System.out.println("GET OPENID LIST,total="+jo.getLongValue("total")+",count="+jo.getIntValue("count")+",next_openid="+jo.getString("next_openid"));
							//设置下一个查询起始Openid
							nextOpenId = jo.getString("next_openid");
							JSONObject data = jo.getJSONObject("data");
							if(data != null){
								//获取open id列表
								JSONArray openidArray = data.getJSONArray("openid");
								wxOpenidService.addWxOpenidList(openidArray);
							}
							if(jo.getIntValue("count") == 0 || nextOpenId == null || "".equals(nextOpenId)){
								shutdown();
							}
						}
					} catch (Exception e) {
						e.printStackTrace();
						request.getServletContext().setAttribute("openid_sync", "0");
					}
				}
			}
			public void shutdown(){
				WeixinUtil.syncOpenidStatus = false;
				System.out.println("= Sync openid complete =");
				flag = false;
			}
		};
		Thread th = new Thread(orun);
		th.start();
		DwzAjaxResult dwzResult = new DwzAjaxResult("200", "同步已开始至后台进行，请耐心等待！", "wxOpenidList", "", "");
		return JSON.toJSONString(dwzResult);
	}
	
	private JSONObject getUserList(String nextOpenid){
		JSONObject json = WeixinUtil.getUserList(nextOpenid, getWxAccessToken());
		if(json.containsKey("errcode")){
			if(json.getString("errmsg").indexOf("access_token is invalid")!=-1){
				//access token过期，则需要刷新access token
				JSONObject jo = WeixinUtil.getAccessToken();
				if(!jo.containsKey("errcode")){
					WxToken token = new WxToken();
					token.setToken_key(WX_TOKEN_KEY.NORMAL_ACCESS_TOKEN.getKey());
					token.setCreate_time(System.currentTimeMillis());
					token.setToken_value(jo.getString("access_token"));
					token.setExpire_seconds(jo.getInteger("expires_in"));
					wxTokenService.addNewWxTokenOrUpdate(token);
					
					json = WeixinUtil.getUserList(nextOpenid, token.getToken_value());
				}else{
					System.out.println("REGET ACESS TOKEN ERROR:" + JSON.toJSONString(jo));
				}
			}
		}
		return json;
	}
	
	@RequestMapping(value="/syncUserInfo")
	@ResponseBody
	public String syncUserInfo(final HttpServletRequest request){
		if(WeixinUtil.syncUserInfoStatus){
			return JSON.toJSONString(new DwzAjaxResult("300", "同步已在进行", "", "", ""));
		}
		final WxToken token = wxTokenService.getWxTokenByKey(WX_TOKEN_KEY.NORMAL_ACCESS_TOKEN.getKey());
		if(token == null || !token.isActive() || token.getToken_value() == null || "".equals(token.getToken_value())){
			return JSON.toJSONString(new DwzAjaxResult("300", "获取AccessToken失败", "", "", ""));
		}
		//标识Openid已经在同步状态
		WeixinUtil.syncUserInfoStatus = true;
		Runnable orun = new Runnable() {
			private WxToken tk;
			private boolean flag = true;
			private long page = 1;
			private int psize = 100;
			
			@Override
			public void run() {
				if(tk == null){
					//初始化token
					tk = token;
				}
				System.out.println("= Sync userinfo start =");
				
				while(flag){
					try {
						List<WxOpenid> list = wxOpenidService.getWxOpenidsWithoutUnionid(page, psize);
						if(list.size() == 0 || list.size() < psize){
							shutdown();
						}
						for(WxOpenid wo : list){
							//调用微信用户基本信息接口
							WxOpenid userInfo = getUserInfo(wo.getOpenid());
							wxOpenidService.addNewWxOpenidOrUpdate(userInfo);
						}
						page += 1;
					} catch (Exception e) {
						e.printStackTrace();
						request.getServletContext().setAttribute("userinfo_sync", "0");
					}
				}
			}
			public void shutdown(){
				flag = false;
				WeixinUtil.syncUserInfoStatus = false;
				System.out.println("= Sync userinfo complete =");
				
			}
		};
		Thread th = new Thread(orun);
		th.start();
		DwzAjaxResult dwzResult = new DwzAjaxResult("200", "同步已开始至后台进行，请耐心等待！", "wxOpenidList", "", "");
		return JSON.toJSONString(dwzResult);
	}
	
	private WxOpenid getUserInfo(String openid){
		JSONObject json = WeixinUtil.getUserInfo(openid, getWxAccessToken());
		if(json.containsKey("errcode")){
			if(json.getString("errmsg").indexOf("access_token is invalid")!=-1){
				//access token过期，则需要刷新access token
				JSONObject jo = WeixinUtil.getAccessToken();
				if(!jo.containsKey("errcode")){
					WxToken token = new WxToken();
					token.setToken_key(WX_TOKEN_KEY.NORMAL_ACCESS_TOKEN.getKey());
					token.setCreate_time(System.currentTimeMillis());
					token.setToken_value(jo.getString("access_token"));
					token.setExpire_seconds(jo.getInteger("expires_in"));
					wxTokenService.addNewWxTokenOrUpdate(token);
					
					json = WeixinUtil.getUserInfo(openid, token.getToken_value());
				}else{
					System.out.println("REGET ACESS TOKEN ERROR:" + JSON.toJSONString(jo));
				}
			}
		}
		return JSONObject.parseObject(json.toJSONString(), WxOpenid.class);
	}
	
	private String getWxAccessToken(){
		WxToken token = wxTokenService.getWxTokenByKey(WX_TOKEN_KEY.NORMAL_ACCESS_TOKEN.getKey());
		if(token != null){
			return token.getToken_value();
		}
		return "";
	}
获取用户列表 
public void addWxOpenidList(JSONArray openidArray) {
		WxOpenid wxo = new WxOpenid();
		wxo.setSubscribe(1);	//只添加openid列表，默认为关注状态为：已关注
		for(int i=0; i<openidArray.size(); i++){
			Object obj = openidArray.get(i);
			if(obj == null) continue;
			wxo.setOpenid(obj.toString());
			List<WxOpenid> list = wxOpenidMapper.selectByCondition(wxo);
			if(list.size() > 0){
				//union id 已经存在, 若果Open id不存在，则添加open id
				wxo = list.get(0);
				if(wxo.getSubscribe() != 1){
					wxo.setSubscribe(1);
					wxOpenidMapper.update(wxo);
				}
			}else{
				wxOpenidMapper.save(wxo);
			}
		}
	}

public static JSONObject getUserInfo(String openid, String accessToken){
		String resp = CommonUtil.httpsRequest("https://api.weixin.qq.com/cgi-bin/user/info?access_token=" + accessToken + "&openid=" + openid, "GET", null);
		JSONObject jo = JSONObject.parseObject(resp);
		if(jo.containsKey("errcode")){
			log.error("[WAP] GET USER INFO ERROR: " + jo.getString("errcode") + ":" + jo.getString("errmsg"));	
		}
		return jo;
	}

保存或更新token

public WxToken addNewWxTokenOrUpdate(WxToken wxToken) {
		WxToken token = wxTokenMapper.selectByKey(wxToken.getToken_key());
		if(token != null){
			token.setCreate_time(System.currentTimeMillis());
			//token已存在，则更新token
			wxToken.setId(token.getId());
			wxTokenMapper.update(wxToken);
			//如果更新的是noral_access_token，则需要删除失效的js ticket
			if(WX_TOKEN_KEY.NORMAL_ACCESS_TOKEN.getKey().equals(wxToken.getToken_key())){
				WxToken ticket = wxTokenMapper.selectByKey(WX_TOKEN_KEY.JSSDK_TICKET.getKey());
				if(ticket != null){
					wxTokenMapper.delete(ticket.getId());
				}
			}
		}else{
			token = new WxToken();
			token.setExpire_seconds(wxToken.getExpire_seconds());
			token.setToken_key(wxToken.getToken_key());
			token.setToken_value(wxToken.getToken_value());
			token.setCreate_time(System.currentTimeMillis());
			wxTokenMapper.save(wxToken);
		}
		return wxToken;
	}


public List<WxOpenid> getWxOpenidsWithoutUnionid(long page, int psize) {
		QueryPager pager = new QueryPager();
		pager.setPageNum(page);
		pager.setNumPerPage((long)psize);
		WxOpenid wxo = new WxOpenid();
		wxo.setPager(pager);
		return wxOpenidMapper.selectWithoutUnionid(wxo);
	}

public WxToken getWxTokenByKey(String key) {
		WxToken token = wxTokenMapper.selectByKey(key);
		boolean isSave = false;
		if(token == null || !token.isActive()){
			JSONObject tokenJo = WeixinUtil.getAccessToken();
			if(tokenJo != null && tokenJo.containsKey("access_token")){
				if(token == null){
					//保存新token
					token = new WxToken();
					isSave = true;
				}
				token.setExpire_seconds(tokenJo.getInteger("expires_in"));
				token.setToken_value(tokenJo.getString("access_token"));
				token.setToken_key(key);
				token.setCreate_time(System.currentTimeMillis());
				if(isSave){
					wxTokenMapper.save(token);
				}else{
					wxTokenMapper.update(token);
				}
			}
		}
		return token;
	}

微信订阅号事件、消息处理 

@RequestMapping("/weixinConnector" + GlobalConstant.STATIC_SUFFIX)
	public void weixinConnector(HttpServletRequest request, HttpServletResponse response){
		if(request.getMethod().equalsIgnoreCase(RequestMethod.GET.toString())){
			//GET处理签名验证
			String signature = request.getParameter("signature");
			String nonce = request.getParameter("nonce");
			String timestamp = request.getParameter("timestamp");
			String echostr = request.getParameter("echostr");
			WxSignature sign = new WxSignature(signature, nonce, timestamp);
			if(WeixinUtil.verifySignature(sign)){
				printJson(echostr, response);
				return;
			}
		}else{
			//POST处理菜单创建、消息回复等
			WxNotify notify = WeixinUtil.parseNotify(request);
			String msgType = notify.getMsgType();
			String fromOpenid = notify.getFromUserName();
			
			//处理事件推送
			if("event".equals(msgType)){
				if("subscribe".equals(notify.getEvent())){
					//关注自动回复消息（暂无实现回复图片、视频、语音等）
					WxConfig config = wxConfigService.getWxConfigByKey(WX_CONFIG_KEY.SUBSCRIBE_REPLY_KEY.getKey());
					if(config != null && config.getValue() != null){
						String keyValue = config.getValue();
						if(WX_CONFIG_KEY.SUBSCRIBE_REPLY_TEXT.getKey().equals(keyValue)){
							//回复文本信息
							doReplyText(notify.getToUserName(), fromOpenid, WX_CONFIG_KEY.SUBSCRIBE_REPLY_TEXT, response);
						}
						else if(WX_CONFIG_KEY.SUBSCRIBE_REPLY_ARTICLE.getKey().equals(keyValue)){
							//回复图文信息
							doReplyArticles(notify.getToUserName(), fromOpenid, response);
						}
					}
				}
				if("subscribe".equals(notify.getEvent()) || "unsubscribe".equals(notify.getEvent())){
					//关注和取消关注事件，需要更新数据库Open id状态
					//获取用户信息（UionID）机制
					try {
						WxOpenid userInfo = getUserInfo(fromOpenid);
						//保存open id 和 union id信息
						wxOpenidService.addNewWxOpenidOrUpdate(userInfo);
					} catch (Exception e) {
						e.printStackTrace();
						//获取AccessToken失败，则按接口文档说明返回空字符串
						printJson("", response);
						return;
					}
					
				}
				if("TEMPLATESENDJOBFINISH".equals(notify.getEvent())) {
					//模版消息发送任务完成事件
					printJson("", response);
					return;
				}
			}else if("text".equals(msgType) || "image".equals(msgType) || "voice".equals(msgType) || "video".equals(msgType) || "shortvideo".equals(msgType) || "location".equals(msgType) || "link".equals(msgType)){
				fromOpenid = notify.getFromUserName();
				//处理消息回复（暂无实现回复图片、视频、语音等）
				WxConfig config = wxConfigService.getWxConfigByKey(WX_CONFIG_KEY.COMMON_REPLY_KEY.getKey());
				if(config != null && config.getValue() != null){
					String keyValue = config.getValue();
					if(WX_CONFIG_KEY.COMMON_REPLY_TEXT.getKey().equals(keyValue)){
						//回复文本信息
						doReplyText(notify.getToUserName(), fromOpenid, WX_CONFIG_KEY.COMMON_REPLY_TEXT, response);
					}
					else if(WX_CONFIG_KEY.COMMON_REPLY_ARTICLE.getKey().equals(keyValue)){
						//回复图文信息
						doReplyArticles(notify.getToUserName(), fromOpenid, response);
					}
				}
			}
		}
	}

其他实时服务号授权等代码就省略了。。。

dyyaries
关注
  • 1
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
网页中获取微信用户是否关注订阅号的思路
ChesterChai的博客
09-22 439
订阅号要获取微信用户是否关注，请保证在同一个微信开放平台帐号下有一个服务号，否则可能很难实现。 在平时的业务工程中我们需要了解用户是否关注了微信公众号才能继续往下操作。这种操作对服务号来说是很容易的，具体可以参考微信开发文档>微信网页开发>网页授权 但是订阅号是没有这个功能的，也就是无法通过这个机制知道微信用户是否关注，本文就是要解决这个问题。 在微信开发文档>用户管理>获取用户基本信息(UnionID机制)>UnionID机制说明中有提到： 开发者可通过OpenID来获.
微信订阅号强制用户关注思路
weixin_34186931的博客
09-14 827
2019独角兽企业重金招聘Python工程师标准>>> ...
关注公众号 源码
08-12
C#关注公众号源码 获取用户openid
小程序内支付后，可以强制关注公众号吗
易客酷云目录
07-19 3930
细心的用户会发现，并不是每次支付完成都会被关注服务号，因为支付页面下边的推荐关注的复选框也有不默认勾选的情况。微信支付总共有七种类型(如下图所示)，其中与公众号直接相关拥有支付后「默认关注」功能的，是公众号支付、刷卡支付、扫码支付以及小程序支付这四种。其中「公众号支付」、「刷卡支付」和「扫码支付」这三类推荐关注的复选框都是默认勾选的，也就是顾客支付成功后自动关注服务号。3、登录「商户平台」，进入页面顶部的「营销中心」，在左侧边栏中找到「支付后配置」选项，在这里设置小程序完成支付后要关注的服务号。
关注微信公众号后，才可以参加活动等等问题
u013791315的专栏
07-22 3791
最近在做手机端微信的项目。准确来说我是前端开发人员，但是由于在学校时学的java，正好项目是java写的。开始时项目是有框架了的，现在项目需要加关注后，才可以领取奖励之类的，详情见如下网址：      http://mp.weixin.qq.com/wiki/14/bb5031008f1494a59c6f71fa0f319c66.html 一个用户类，里面放自己需要的东西： publ
破解网页关注公众号才能继续观看
最新发布
molaifeng的专栏
11-19 1497
破解网页关注公众号才能继续观看
.NetCore实现微信订阅号自动回复功能
09-16
.NetCore实现微信订阅号自动回复功能
微信订阅号开发java_demo
01-31
微信订阅号开发java demo,只是接收、发送消息的接口。
微信个人订阅号简单实现在线收款
11-05
微信个人订阅号简单实现在线收款
微信订阅号python服务端源代码
01-17
微信订阅号的python服务端，响应处理用户消息返回结果，实现天气查询、菜谱查询等。
微信订阅号
05-29
微信订阅号，写了自定义菜单和自动回复用户文本内容
微信公众号开发 - token获取（保证同一时间段内只请求一次）
u012693016的博客
11-27 3188
创建wx_token表，存放token CREATE TABLE `wx_token` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增主键', `token_type` varchar(20) NOT NULL COMMENT 'token类型，access_token：基础token，jsapi_ticket：j...
引导微信用户关注公众号(详细步骤加代码)
我就叫贝塔
07-09 1万+
实现效果: 当用户进入公众号h5页面,弹窗提示,是否要关注公众号 流程 1.用户在微信公众号端进入h5页面时,前端从后端数据库获取到用户关注状态. 2.如果用户未关注,弹窗提示,是否关注公众号,不关注则取消弹窗,关注的话跳转到微信关注页面 3.一天内未关注用户只会接收到一次弹窗提示 4.更新用户的关注状态入库 一,用户在微信公众号端进入h5页面时,前端从后端数据库获取到用户关注状态. 微信用户是否关注公众号,需要咱们去问微信服务器要数据 微信官方文档 获取用户基本信息（包括UnionID机制和用户是
微信小程序之token验证
倾城一笑
01-08 2万+
作用：防止攻击，避免其他人随意的调用接口，以保证数据的安全性。 在使用token前，首先了解下缓存的使用，比如（memcache/redis）等，在配置好memcache或者redis缓存后，下面就开始代码讲解    首先要生成token将token存入缓存中设置缓存时间 ,然后将token返回给小程序的前端   ，前端获取token后 验证，验证后将token通过headers传到后台，后台...
android 微信登陆功能,Android 实现微信登录详解
weixin_36182226的博客
05-25 4653
前言分享到微信朋友圈的功能早已经有了，但微信登录推出并不久，文档写的也并不是很清楚，这里记录分享一下。正文一、准备二、 代码2.1唤起微信登录参考官网文档：资源中心/移动应用开放/接入指南/Android接入指南private IWXAPI mWeixinAPI;private void loginWithWeixin() {if (mWeixinAPI == null) {mWeixinAPI...
wx第一次验证token
后端菜鸡
07-05 530
<?php define("TOKEN", "wxx"); $wechatObj = new wechatCallbackapiTest(); $wechatObj->valid(); class wechatCallbackapiTest { public function valid() { $echoStr = $_GET["echostr"];...
微信公众号h5获取用户openId的方法和步骤
江湖行骗老中医
01-19 2439
微信h5静默、非静默授权获取用户openId的方法和步骤: 一、openId是什么？ openId是用户在当前公众号下的唯一标识（‘身份证’），就是说通过这个openId，就能区分在这个公众号下具体是哪个用户。 二、openId有什么用？ 假如用户A在当前公众号下购买了一件商品，用户的下单信息肯定要存储到后台数据库，那根据什么进行存储呢？openId是用户在当前公众号下的唯一标识，通过openId和用户的下单购买信息进行键值对的数据绑定。那么我要查询该用户购买过什么商品，就能够通过openId去查询
微信公众号获取OpenId（未授权）（需要关注公众号）
HanKin_的博客
01-09 1万+
文章的一开始，我先解释下微信公众号的openId。 openId是微信对于用户的唯一辨识，只要有用户关注你的公众号，微信会通过公众号和用户微信号通过一种算法生成一种唯一标识码，也就是openId，用数学表达式也就是说： x=你的公众号，y=用户微信号，f（）函数表示算法 那么openId = f（x,y）; 后面就讲讲怎么获取到openId把，我下面先讲一种简易的方式（还有一种后续有空加上
微信公众号获取OpenId（用户授权）（无需关注公众号）以及获取用户基本信息
热门推荐
HanKin_的博客
02-01 4万+
上一个博客也写了微信公众号获取OpenId，但是现在这个和上一个有什么区别呢。 其实呢，是差不多的，只是这个是通过用户授权。 但是，又会有人问了，明明可以未授权获取到用户的openId，那我为什么要让用户进行授权呢，我偷偷的获取不就好了吗？ 好像很有道理，但是呢，那微信又干嘛多一个接口呢？ 其实，授权和未授权的区别就是：未授权的获取方式是需要用户关注你的公众号的，但是，授权
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dyyaries

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值