微信小程序订阅消息推送实战图文教程(Java Spring Boot + Redis)

#小程序appid
wechat.appid=xxxxx
#小程序密钥
wechat.secret=xxxxxx
#订阅消息的模板id
wechat.templateId=xxxxxxxxx
#登录wx登录验证
wechat.loginUrl=https://api.weixin.qq.com/sns/jscode2session
#wx订阅消息发送
wechat.sendUrl=https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    public void set(String key, String value, long expireSeconds) {
        redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(expireSeconds));
    }
    public boolean setIfAbsent(String key, String value, long expireSeconds) {
        return Boolean.TRUE.equals(redisTemplate.opsForValue()
                .setIfAbsent(key, value, Duration.ofSeconds(expireSeconds)));
    }
    public Long executeLua(String script, String key, String value) {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(script);
        redisScript.setResultType(Long.class);
        return redisTemplate.execute(redisScript, Collections.singletonList(key), value);
    }
}

@Service
public class AccessTokenService {
    @Autowired
    private RedisUtils redisUtils;
    private static final String TOKEN_KEY = "WECHAT:ACCESS_TOKEN";
    private static final String LOCK_KEY = "WECHAT:APPEAL_TOKEN_LOCK";
    private static final long LOCK_EXPIRE_SECONDS = 5;
    private static final String SUBSCRIBE_PREFIX = "SUBSCRIBE:";
    private static final String LUA_RELEASE_SCRIPT =
            "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    /**
     * 获取AccessToken
     *
     * @return
     */
    public String getAccessToken() {
        //先取缓存
        String token = (String) redisUtils.get(TOKEN_KEY);
        if (token != null && !token.isEmpty()) {
            return token;
        }
        //缓存失效，尝试加锁
        String lockValue = String.valueOf(System.currentTimeMillis());
        boolean locked = redisUtils.setIfAbsent(LOCK_KEY, lockValue, LOCK_EXPIRE_SECONDS);
        if (locked) {
            try {
                // 双重检查
                token = (String) redisUtils.getWechat(TOKEN_KEY);
                if (token != null) {
                    return token;
                }
                return refreshAccessToken();
            } finally {
                redisUtils.executeLua(LUA_RELEASE_SCRIPT, LOCK_KEY, lockValue);
            }
        } else {
            // 未获得锁，等待后重试
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return getAccessToken();
        }
    }
    /**
     * 刷新AccessToken
     */
    private String refreshAccessToken() {
        String url = String.format(
                "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s",
                appid, secret
        );
        try {
            String response = HttpRequest.get(url).timeout(5000).execute().body();
            JSONObject json = JSONUtil.parseObj(response);
            if (json.containsKey("errcode")) {
                throw new CommonException("微信获取AccessToken失败: " + json.getStr("errmsg"));
            }
            String token = json.getStr("access_token");
            Integer expiresIn = json.getInt("expires_in");
            // 存入 Redis，有效期设为 7000 秒（微信是7200秒）
            redisUtils.setWechat(TOKEN_KEY, token, expiresIn - 200);
            return token;
        } catch (Exception e) {
            throw new CommonException("获取AccessToken网络异常", e);
        }
    }
}

@Service
@Slf4j
public class SubscribeMessageService {
    @Value("${wechat.appid}")
    private String appid;
    @Value("${wechat.secret}")
    private String secret;
    @Value("${wechat.templateId}")
    private String templateId;
    @Value("${wechat.sendUrl}")
    private String sendUrl;
    private static final String SUBSCRIBE_PREFIX = "SUBSCRIBE:";
    @Autowired
    private RedisUtils redisUtils;
    /**
     * 记录用户订阅
     */
    public void record() {
        // 获取登录用户获取对应的openId
        SaBaseLoginUser loginUser = null;
        try {
            loginUser = StpLoginUserUtil.getLoginUser();
            String openId = bizUserService.getOpenIdById(loginUser.getId());
            String key = SUBSCRIBE_PREFIX + templateId + ":" + openId;
            redisUtils.setWechat(key, "1", 30 * 24 * 3600L); // 存储30天
        } catch (Exception e) {
            throw new CommonException(e.getMessage());
        }
    }
    /**
     * 判断用户是否订阅
     */
    public boolean isSubscribed(String openId, String templateId) {
        String key = SUBSCRIBE_PREFIX + templateId + ":" + openId;
        return "1".equals(redisUtils.getWechat(key));
    }
    private void getUserListByGridId(String openId) {
        // 此处代码可替换为具体的业务实现  就是获取需要推送用户的openId
        // 推送消息给网格员
        // 判断用户是否订阅了消息
        if (isSubscribed(openId, templateId)) {
            Map<String, String> dataMap = new HashMap<>();
            dataMap.put("thing1", "意见提醒");
            dataMap.put("thing2", "这是一条测试信息");
            dataMap.put("time3", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            boolean b = sendSubscribeMessage(openId, templateId, null, dataMap);
            if (!b) {
                throw new CommonException("推送消息失败，请重试");
            }
        }
    }
    /**
     * 发送订阅消息
     */
    public boolean sendSubscribeMessage(String openId, String templateId,
                                        String page, Map<String, String> data) {
        String accessToken = getAccessToken();
        String url = sendUrl + accessToken;
        JSONObject requestBody = new JSONObject();
        requestBody.set("touser", openId);
        requestBody.set("template_id", templateId);
        if (page != null && !page.isEmpty()) {
            requestBody.set("page", page);
        }
        requestBody.set("miniprogram_state", "formal");
        JSONObject dataJson = new JSONObject();
        for (Map.Entry<String, String> entry : data.entrySet()) {
            JSONObject item = new JSONObject();
            item.set("value", entry.getValue());
            dataJson.set(entry.getKey(), item);
        }
        requestBody.set("data", dataJson);
        try {
            String response = HttpRequest.post(url)
                    .body(requestBody.toString())
                    .timeout(5000)
                    .execute()
                    .body();
            JSONObject result = JSONUtil.parseObj(response);
            Integer errCode = result.getInt("errcode");
            return errCode == null || errCode == 0;
        } catch (Exception e) {
            log.error("调用微信发送消息接口异常", e);
            return false;
        }
    }
}

@RestController
@RequestMapping("/api/subscribe")
public class SubscribeController {
    @Autowired 
    private SubscribeMessageService subService;
    /**
     * 前端需要订阅消息推送
    */
    @PostMapping("/record")
    public Result record(@RequestBody Map<String, String> req) {
        subService.record(req.get("openId"),req.get("templateId"));
        return Result.success("订阅成功");
    }
}

Page({
  subscribe() {
    const templateId = '你的模板ID'; // 与后端配置一致
    wx.requestSubscribeMessage({
      tmplIds: [templateId],
      success(res) {
        if (res[templateId] === 'accept') {
          // 用户同意，上报后端
          wx.request({
            url: 'https://你的域名/api/subscribe/record',
            method: 'POST',
            data: { openId: '当前用户的openId' }, // openId 需提前通过 wx.login 获取
            success() { wx.showToast({ title: '订阅成功' }); }
          });
        }
      }
    });
  }
});