spring boot +微信小程序项目，通过微信公众号实现指定用户消息长期推送

已于 2023-09-14 15:45:57 修改
阅读量2k 收藏 15
点赞数 3
文章标签： java spring boot
于 2023-09-13 16:27:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/listenFen/article/details/132856720
版权
本文介绍了如何在微信小程序中实现用户登录后的公众号绑定，包括获取UnionId，处理关注、取关及消息发送事件，配置验签接口，以及使用模板消息发送功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

流程

用户登录小程序，后台记录用户的小程序openId和用户唯一的UnionId。然后用户触发公众号事件（关注公众号或者发送指定消息），后台获取到用户公众号的openId,再调用接口通过公众号的openId查询用户的UnionId，再和数据库里的UnionId进行匹配，将用户的公众号openId存入数据库。此后即可通过userId找到公众号openId 实现公众号消息推送。
在这里插入图片描述

1.开通公众号

这个直接操作就好了

2.配置公众号验签接口

添加验签接口

	/**
     * 服务器有效性验证
     */
    @GetMapping("connect")
    public String verifyToken(HttpServletRequest request) {
        String signature = request.getParameter("signature");
        String timestamp = request.getParameter("timestamp");
        String nonce = request.getParameter("nonce");
        String echostr = request.getParameter("echostr");
        log.info("signature: {} nonce: {} echostr: {} timestamp: {}", signature, nonce, echostr, timestamp);
        if (this.checkSignature(signature, timestamp, nonce)) {
            log.info("token ok");
            return echostr;
        }
        return echostr;
    }

将接口配置到公众号上
在这里插入图片描述

3.设置用户关注、取关以及发送消息事件处理

接口名称和验签接口相同 只是验签是GET请求 事件处理是POST请求

	/**
     * 用户公众号关注/取关事件回调
     */
    @PostMapping(value = "/connect")
    public void getXmlInfo(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        req.setCharacterEncoding("UTF-8"); // 接收请求时的编码。
        resp.setCharacterEncoding("UTF-8"); // 响应给浏览器的编码。
        Map<String, String> map = XMLUtil.parseXml(req);
        log.info(JSONObject.toJSONString(map));

        if ( map.get("MsgType").equals("text")){
            if (map.get("Content").equals("求购留言")){
                String result = wechatOfficialAccountService.replySubscribeInfo(map);
                resp.setCharacterEncoding("UTF-8");
                resp.getWriter().println(result);
            }
        }else {
            if (map.get("Event").equals("subscribe")){
                wechatOfficialAccountService.subscribeInfo(map);
            } else if (map.containsKey("Event") && map.get("Event").equals("unsubscribe")) {
                wechatOfficialAccountService.unSubscribeInfo(map);
            }
        }
    }

关注时给用户绑定openId

	public void subscribeInfo(Map<String, String> map){
        WeChatEventInfo eventInfo = new WeChatEventInfo()
                .setToUserName(map.get("ToUserName"))
                .setFromUserName(map.get("FromUserName"))
                .setCreateTime(map.get("CreateTime"))
                .setMsgType(map.get("MsgType"))
                .setEvent(map.get("Event"));
        String accessToken = getToken();
        log.info("accessToken:{}",accessToken);
        String unionId = getUserInfo(accessToken,eventInfo.getFromUserName());
        if(StrUtil.isNotBlank(unionId)){
            wxCustomerService.bindOfficialAccountOpenId(unionId,eventInfo.getFromUserName());
        }
    }

回复指定消息时给用户绑定openId

/**
     * 回复求购留言进行关注
     */
    public String replySubscribeInfo(Map<String, String> map) throws Exception {
        WeChatEventInfo eventInfo = new WeChatEventInfo()
                .setToUserName(map.get("ToUserName"))
                .setFromUserName(map.get("FromUserName"))
                .setCreateTime(map.get("CreateTime"))
                .setMsgType(map.get("MsgType"))
                .setContent(map.get("content"));

        String accessToken = getToken();
        log.info("accessToken:{}",accessToken);
        String unionId = getUserInfo(accessToken,eventInfo.getFromUserName());
        ReplyMessage result = new ReplyMessage()
                .setToUserName(eventInfo.getFromUserName())
                .setFromUserName(eventInfo.getToUserName())
                .setCreateTime(System.currentTimeMillis())
                .setMsgType("text");
        if(StrUtil.isNotBlank(unionId)){
            wxCustomerService.bindOfficialAccountOpenId(unionId,eventInfo.getFromUserName());
            result.setContent("已为您开通求购留言通知");
        }else {
            result.setContent("开通失败,暂未获取到您的用户信息");
        }
        return XMLUtil.textMessageToXml(result);
    }

取关时解绑用户openId

 public void unSubscribeInfo(Map<String, String> map){
        WeChatEventInfo eventInfo = new WeChatEventInfo()
                .setToUserName(map.get("ToUserName"))
                .setFromUserName(map.get("FromUserName"))
                .setCreateTime(map.get("CreateTime"))
                .setMsgType(map.get("MsgType"))
                .setEvent(map.get("Event"));
        wxCustomerService.unSubscribeInfo(eventInfo.getFromUserName());
    }

4.申请消息模板

5.给指定用户发送消息

前三步代码

依赖

		<dependency>
            <groupId>com.github.binarywang</groupId>
            <artifactId>weixin-java-mp</artifactId>
            <version>4.0.0</version>
        </dependency>

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.1</version>
        </dependency>
        <!-- java对象转换为xml字符串 -->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.19</version>
        </dependency>

接口层

接口需要放行

@RestController
@RequestMapping("wechat")
@Slf4j
public class WeChatController {

    private final WechatOfficialAccountService wechatOfficialAccountService;
    private static final String TOKEN = "platformYz";

    public WeChatController(WechatOfficialAccountService wechatOfficialAccountService) {
        this.wechatOfficialAccountService = wechatOfficialAccountService;
    }

    /**
     * 服务器有效性验证
     */
    @GetMapping("connect")
    public String verifyToken(HttpServletRequest request) {
        String signature = request.getParameter("signature");
        String timestamp = request.getParameter("timestamp");
        String nonce = request.getParameter("nonce");
        String echostr = request.getParameter("echostr");
        log.info("signature: {} nonce: {} echostr: {} timestamp: {}", signature, nonce, echostr, timestamp);
        if (this.checkSignature(signature, timestamp, nonce)) {
            log.info("token ok");
            return echostr;
        }
        return echostr;
    }

    /**
     * 用户公众号关注/取关事件回调
     */
    @PostMapping(value = "/connect")
    public void getXmlInfo(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        req.setCharacterEncoding("UTF-8"); // 接收请求时的编码。
        resp.setCharacterEncoding("UTF-8"); // 响应给浏览器的编码。
        Map<String, String> map = XMLUtil.parseXml(req);
        log.info(JSONObject.toJSONString(map));

        if ( map.get("MsgType").equals("text")){
            if (map.get("Content").equals("求购留言")){
                String result = wechatOfficialAccountService.replySubscribeInfo(map);
                resp.setCharacterEncoding("UTF-8");
                resp.getWriter().println(result);
            }
        }else {
            if (map.get("Event").equals("subscribe")){
                wechatOfficialAccountService.subscribeInfo(map);
            } else if (map.containsKey("Event") && map.get("Event").equals("unsubscribe")) {
                wechatOfficialAccountService.unSubscribeInfo(map);
            }
        }
    }

    private boolean checkSignature(String signature, String timestamp, String nonce) {
        String[] str = new String[]{TOKEN, timestamp, nonce};
        //排序
        Arrays.sort(str);
        //拼接字符串
        StringBuffer buffer = new StringBuffer();
        for (String s : str) {
            buffer.append(s);
        }
        //进行sha1加密
        String temp = SHA1.encode(buffer.toString());
        //与微信提供的signature进行匹对
        return signature.equals(temp);
    }
}

service层


import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Optional;


@Service
@Slf4j
public class WechatOfficialAccountService {

    private final WxCustomerService wxCustomerService;
    private final RestTemplate restTemplate;

    private final String appId;
    private final String appSecret;
    private static final String USER_INFO_URL = "https://api.weixin.qq.com/cgi-bin/user/info?access_token=%s&openid=%s&lang=zh_CN";
    private static final String TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/stable_token";
    public WechatOfficialAccountService(WxCustomerService wxCustomerService, RestTemplate restTemplate,
                                        @Value("${wx.gzh.appId}") String appId,
                                        @Value("${wx.gzh.secret}") String appSecret) {
        this.wxCustomerService = wxCustomerService;
        this.restTemplate = restTemplate;
        this.appId = appId;
        this.appSecret = appSecret;
    }


    public void subscribeInfo(Map<String, String> map){
        WeChatEventInfo eventInfo = new WeChatEventInfo()
                .setToUserName(map.get("ToUserName"))
                .setFromUserName(map.get("FromUserName"))
                .setCreateTime(map.get("CreateTime"))
                .setMsgType(map.get("MsgType"))
                .setEvent(map.get("Event"));
        String accessToken = getToken();
        log.info("accessToken:{}",accessToken);
        String unionId = getUserInfo(accessToken,eventInfo.getFromUserName());
        if(StrUtil.isNotBlank(unionId)){
            wxCustomerService.bindOfficialAccountOpenId(unionId,eventInfo.getFromUserName());
        }
    }

    /**
     * 回复求购留言进行关注
     */
    public String replySubscribeInfo(Map<String, String> map) throws Exception {
        WeChatEventInfo eventInfo = new WeChatEventInfo()
                .setToUserName(map.get("ToUserName"))
                .setFromUserName(map.get("FromUserName"))
                .setCreateTime(map.get("CreateTime"))
                .setMsgType(map.get("MsgType"))
                .setContent(map.get("content"));

        String accessToken = getToken();
        log.info("accessToken:{}",accessToken);
        String unionId = getUserInfo(accessToken,eventInfo.getFromUserName());
        ReplyMessage result = new ReplyMessage()
                .setToUserName(eventInfo.getFromUserName())
                .setFromUserName(eventInfo.getToUserName())
                .setCreateTime(System.currentTimeMillis())
                .setMsgType("text");
        if(StrUtil.isNotBlank(unionId)){
            wxCustomerService.bindOfficialAccountOpenId(unionId,eventInfo.getFromUserName());
            result.setContent("已为您开通求购留言通知");
        }else {
            result.setContent("开通失败,暂未获取到您在玉农智链中的用户信息");
        }
        return XMLUtil.textMessageToXml(result);
    }
    private String getUserInfo(String accessToken,String openId) {
        String url = String.format(USER_INFO_URL, accessToken, openId);
        String json = restTemplate.getForObject(url, String.class);
        JSONObject jsonObject = JSONObject.parseObject(json);
        log.info("json:{}",json);
        return jsonObject.getString("unionid");
    }
    private String getToken() {
        ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(TOKEN_URL,new JSONObject().fluentPut("grant_type","client_credential").fluentPut("appid",appId).fluentPut("secret",appSecret).toJSONString(), JSONObject.class);
        JSONObject json = Optional.ofNullable(responseEntity.getBody()).orElse(new JSONObject());
        restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
        log.info("access_token_json:{}",json.toJSONString());
        return json.getString("access_token");
    }

    public void unSubscribeInfo(Map<String, String> map){

        WeChatEventInfo eventInfo = new WeChatEventInfo()
                .setToUserName(map.get("ToUserName"))
                .setFromUserName(map.get("FromUserName"))
                .setCreateTime(map.get("CreateTime"))
                .setMsgType(map.get("MsgType"))
                .setEvent(map.get("Event"));
        wxCustomerService.unSubscribeInfo(eventInfo.getFromUserName());
    }
}

工具类

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.core.util.QuickWriter;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;
import com.thoughtworks.xstream.io.xml.XppDriver;
import lombok.extern.slf4j.Slf4j;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Slf4j
public class XMLUtil {

    private static final String MESSAGE_TYPE_TEXT = "text";
    public  static Map<String, String> parseXml(HttpServletRequest request) {
        Map<String, String> map = new HashMap<>();

        try(InputStream inputStream = request.getInputStream()){
            // 读取输入流
            SAXReader reader = new SAXReader();
            Document document = reader.read(inputStream);
            // 得到xml根元素
            Element root = document.getRootElement();
            // 得到根元素的所有子节点

            List<Element> elementList = root.elements();

            // 遍历所有子节点
            for (Element e : elementList) {
                map.put(e.getName(), e.getText());
            }
        } catch (IOException |DocumentException e) {
            log.info("xml信息解析失败");
        }
        return map;
    }
    /**
     * 文本消息对象转换成xml
     *
     * @param textMessage 文本消息对象
     * @return xml
     */
    public static String textMessageToXml(ReplyMessage textMessage) {
        XSTREAM.alias("xml", textMessage.getClass());
        return XSTREAM.toXML(textMessage);
    }

    /**
     * 扩展xstream，使其支持CDATA块
     */
    private static final XStream XSTREAM = new XStream(new XppDriver() {
        @Override
        public HierarchicalStreamWriter createWriter(Writer out) {
            return new PrettyPrintWriter(out) {
                // 对所有xml节点的转换都增加CDATA标记
                final boolean cdata = true;

                @Override
                protected void writeText(QuickWriter writer, String text) {
                    if (cdata) {
                        writer.write("<![CDATA[");
                        writer.write(text);
                        writer.write("]]>");
                    } else {
                        writer.write(text);
                    }
                }
            };
        }
    });
    /**
     * 获取默认文本消息
     *
     * @param receiver     接收人
     * @param officialWxid 官方微信id
     * @return 文本消息
     */
    public static ReplyMessage getDefaultReplyMessage(String receiver, String officialWxid) {
        ReplyMessage textMessage = new ReplyMessage();
        textMessage.setToUserName(receiver);
        textMessage.setFromUserName(officialWxid);
        textMessage.setCreateTime(System.currentTimeMillis());
        textMessage.setMsgType(MESSAGE_TYPE_TEXT);
        return textMessage;
    }

}

模板消息发送服务类


import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.StandardCharsets;
import java.util.Objects;
import java.util.Optional;

@Component
@Slf4j
public class WechatOfficialAccountMessageServer {

    private final String appId;
    private final String miniAppId;
    private final String appSecret;


    private final RestTemplate restTemplate;

    private  String accessToken;

    private static final String SEND_URL = "https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=%s";
    private static final String TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/stable_token";

    private WechatOfficialAccountMessageServer(@Value("${wx.gzh.appId}") String appId,
                                               @Value("${wx.xcx.appId}") String miniAppId,
                                               @Value("${wx.gzh.secret}")String appSecret) {

        this.appId = appId;
        this.appSecret = appSecret;
        this.miniAppId = miniAppId;
        this.restTemplate = new RestTemplate();
    }



    /**
     * 消息推送
     *
     * @param templateId  消息模板id
     * @param openId      用户openId
     * @param param 推送对象
     */
    public void pushMessage(String templateId, String openId, WechatOfficialAccountMessageParam param) {
        getInstance();
        param.getMessageDataList().forEach(item->{
            pushMessage(templateId,openId,item,param.getPage());
        });
    }

    private void getInstance(){
        //获取access_token
        ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(TOKEN_URL,new JSONObject().fluentPut("grant_type","client_credential").fluentPut("appid",appId).fluentPut("secret",appSecret).toJSONString(), JSONObject.class);
        JSONObject json = Optional.ofNullable(responseEntity.getBody()).orElse(new JSONObject());
        restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
        this.accessToken = json.getString("access_token");
    }

    /**
     * 消息推送
     *
     * @param templateId  消息模板id
     * @param openId      用户openId
     * @param messageData 消息体
     * @param page
     */
    private void pushMessage(String templateId, String openId, JSONObject messageData, String page) {
        String url = String.format(SEND_URL, this.accessToken);
        //拼接推送的模版
        SendTemplateRequest request = new SendTemplateRequest()
                .setTouser(openId)
                .setTemplateId(templateId)
                .setData(messageData);
        if (StrUtil.isNotBlank(page)){
            JSONObject miniProgram = new JSONObject().fluentPut("appid", miniAppId)
                    .fluentPut("pagepath", page);
            request.setMiniProgram(miniProgram);
        }

        ResponseEntity<SendTemplateResponse> responseEntity = restTemplate.postForEntity(url, JSONObject.toJSONString(request), SendTemplateResponse.class);
        SendTemplateResponse response = Optional.ofNullable(responseEntity.getBody()).orElse(SendTemplateResponse.getInstance());
        if (Objects.requireNonNull(response).isSuccess()) {
            log.info("公众号推送成功");
            return;
        }
        log.error("公众号推送失败：{} {}", response.getErrcode(), response.getErrmsg());
        throw new DefaultException("公众号推送失败：" + response.getErrcode() + response.getErrmsg(), ResponseEnum.OPERATE_FAIL);
    }
}

相关实体类

import lombok.Data;
import lombok.experimental.Accessors;

/**
 * 微信公众号关注取消事件信息
 */
@Data
@Accessors(chain = true)
public class WeChatEventInfo {

    private String toUserName;
    private String fromUserName;
    private String createTime;
    private String msgType;
    private String event;
    private String content;
    private String msgId;
}

@Data
@Accessors(chain = true)
public class ReplyMessage {
    private String ToUserName;
    private String FromUserName;
    private Long CreateTime;
    private String MsgType;
    private String Content;
}

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
class SendTemplateRequest {
    /**
     * 接收者（用户）的 openid
     */
    private String touser;
    /**
     * 所需下发的模板消息的id
     */
    @JSONField(name = "template_id")
    private String templateId;
    /**
     * 模板跳转链接（海外账号没有跳转能力）
     */
    @JSONField(name = "url")
    private String url;
    /**
     * 跳小程序所需数据，不需跳小程序可不用传该数据
     * "miniprogram":{
     *              "appid":"xiaochengxuappid12345",
     *              "pagepath":"index?foo=bar"
     *            }
     * appid	必填	所需跳转到的小程序appid（该小程序appid必须与发模板消息的公众号是绑定关联关系，暂不支持小游戏）
     * pagepath	非必填	所需跳转到小程序的具体页面路径，支持带参数,（示例index?foo=bar），要求该小程序已发布，暂不支持小游戏
     */
    @JSONField(name = "miniprogram")
    private Object miniProgram;
    /**
     * 模板数据
     */
    private Object data;

    /**
     * 防重入id。对于同一个openid + client_msg_id, 只发送一条消息,10分钟有效,超过10分钟不保证效果。若无防重入需求，可不填
     */
    @JSONField(name = "client_msg_id")
    private String clientMsgId;
}

import lombok.Data;
import lombok.experimental.Accessors;

/**
 * 消息推送响应对象
 *
 * @author fenglifei
 */
@Data
@Accessors(chain = true)
public class SendTemplateResponse {
    /**
     * 错误码
     * 0 ok
     * 43116 该模板因滥用被滥用过多，已被限制下发
     */
    private long errcode;
    /**
     * 错误信息
     */
    private String errmsg;
    /**
     * 错误信息
     */
    private String msgid;

    public static SendTemplateResponse getInstance(){
        return new SendTemplateResponse()
                .setErrcode(404L)
                .setErrmsg("");
    }
    public boolean isSuccess() {
        return this.errcode == 0;
    }
}



import com.alibaba.fastjson.JSONObject;
import lombok.Data;

import java.util.List;

@Data
public class WechatOfficialAccountMessageParam {
    private String page;
    private List<JSONObject> messageDataList;
}
listenFeng.
关注
springboot整合微信公众号实现模版消息推送
todoitbo的博客
07-08 1万+
本文将详细介绍如何使用Spring Boot整合微信公众号，实现模版消息推送。我们将从项目的搭建开始，逐步讲解每个步骤，并通过示例代码帮助读者更好地理解和实现这一功能。无论你是新手还是有经验的开发者，都能从中找到实用的技巧和方法。
Spring Boot实现微信公众号/小程序微信支付实战指南
最新发布
danny-IT技术博客
04-17 634
本文将从零开始讲解如何在Spring Boot中实现微信支付功能，涵盖开通流程、版本差异、接口详解、回调处理及企业级注意事项，并附带可直接集成到项目中的代码示例。通过本文的实现方案，开发者可快速构建符合微信支付规范的安全支付系统。实际生产环境中建议结合分布式锁、消息队列等机制保证系统可靠性。以上实现方案已在生产环境验证，可直接用于企业级项目。
springboot实现微信模板消息推送
07-04
springboot实现微信模板消息推送，包含微信端代码。简单封装，方便二次开发！
springboot实现微信公众号模版消息推送
07-09
springboot实现微信公众号模版消息推送，用的是构架：springboot+redis,详细教程：https://blog.youkuaiyun.com/chenhongming888/article/details/95173079
微信公众号开发（服务号）消息推送-测试账号版
weixin_52236586的博客
03-16 479
进度条
微信公众平台向特定用户推送消息
weixin_34138139的博客
10-24 1672
一、首先需要将微信的openid与系统用户绑定。 在用户关注公众平台的时候，回复一个链接，要求用户绑定，可以设计如下消息进行回复，（openid最好进行加密处理，后者还需要用这个字段绑定fakeid）。 欢迎关注有问必答平台,&lt;a href='http://myweixin123.duapp.com/bind.html?openid=@openid'&gt...
微信公众号指定用户消息推送
qq_40881695的博客
09-13 1523
以上方法针对微信公众号提供的测试号，若是正式号（通过认证的），可以调用以下接口替换相关步骤。
SpringBoot(JAVA)整合微信公众号消息推送
weixin_46204877的博客
07-12 5717
在使用JAVA(springboot)开发微信公众号时,有时需要向微信服务器上传一些临时素材,比如图片、语音、视频等。本文将介绍如何实现JAVA微信新增临时素材的功能
Spring Boot后端 + Vue管理员前端 + 微信小程序用户前端 + Vue用户移动端
10-20
这是一个全面的Web应用程序开发项目，整合了Spring Boot后端、Vue.js前端以及微信小程序和Vue.js用户移动端。这个项目展示了现代Web开发中的全栈技术栈，涵盖了从服务器端到客户端的多个层面。以下是对各部分的详细...
基于spring boot + vue + 微信小程序实现外卖系统.zip
03-11
同时，其特色功能如实时更新的信息推送、个性化推荐以及社交分享功能，让用户能够及时获取所需信息，并方便地将优质内容分享至朋友圈或好友，实现信息的高效传播与互动。 【小程序名称】注重数据安全与隐私保护，...
基于springboot框架实现的微信公众号推送天气信息
06-19
最近抖音火起来的使用微信公众测试号每天定时推送天气信息给你的女朋友 设置配置文件中的微信公众测试号的appid和secret，以及接收者的openId（接收者id扫测试号里面的二维码可以看到） wx: appid= secret= ...
向企业微信中的指定用户推送消息
03-14
1、通过企业微信，获取对应的accs_token 2、向企业微信发送对应的消息。
(源码)基于Spring Boot框架的微信公众号推送管理系统.zip
11-19
通过该系统，用户可以方便地进行微信公众号的消息推送和管理。 ## 项目的主要特性和功能 1. 消息推送管理 支持生成和发送文本消息。 提供消息模板管理，支持自定义消息模板。 支持消息的定时推送和即时推送。 ...
手把手教你微信公众号如何给指定用户发送消息提醒
热门推荐
weixin_43401380的博客
09-24 1万+
消息提醒功能是提升用户满意度的最有效方式,基于微信聊天的消息提醒也是现在最常见的消息提醒方式之一,常见的业务场景:从医院里面进行挂号预约,预约成功或是快到预约时间会从微信聊天列表中显示对应的提醒;这种提醒的方式实际上是借助于微信公众号进行实现,当然只是针对于关注公众号的用户进行消息推送.本文主要介绍如何从头开始实现公众号消息推送.
2024-03通过微信公众号给指定用户发送模板消息
m0_68477586的博客
04-01 3406
2）被动回复消息：在用户给公众号发消息后，微信服务器会将消息发到开发者预先在开发者中心设置的服务器地址（开发者需要进行消息真实性验证），公众号可以在5秒内做出回复，可以回复一个消息，也可以回复命令告诉微信服务器这条消息暂不回复。1）网页授权获取用户基本信息：通过该接口，可以获取用户的基本信息（获取用户的OpenID是无需用户同意的，获取用户的基本信息则需用户同意）1）群发消息：公众号可以以一定频次（订阅号为每天1次，服务号为每月4次），向用户群发消息，包括文字消息、图文消息、图片、视频、语音等。
基于SpringBoot实现微信消息推送
m0_63823719的博客
11-19 7803
SpringBoot微信推送
基于SpringBoot开发的推送消息到微信公众号
qq_37013146的博客
05-16 1637
检测到信息微信公众号会立刻推送消息显示
Springboot实现微信公众号模板消息发送
猪大肠的博客
03-20 7570
最近看了一个地推的公众号，每天都会给你推送好几条地推需要的模板消息，好一段时间没有做公众号开发了，最近刚申请了个服务号，刚好可以拿来开发。模板消息需要服务号才可以，申请服务号的话需要企业营业执照，个人的话是没有办法申请的。下面来分享一下我的开发过程。 开发步骤 1.微信公众号服务号 2.准备好 APPID 跟AppSecret 3.开通模板消息，申请一个模板，获取模板ID 4.获取ACCESS_TOKEN 5.获取关注公众号的用户列表 6.选择需要发送的用户，并推送消息 一、资料申请 1.1、获取 APP
SpringBoot整合调用微信模板方法实现微信公众号消息通知推送，Java实现微信公众号给关注用户推送自定义消息通知（手把手从0到1）
Spring Boot-Common On With You
10-24 1万+
本篇文章主要基于Java+Spring Boot+Spring Cloud的应用中接入微信公众号，调用微信的JavaSDK > weixin-java-mp进行应用消息推送，实现业务数据推送到指定的微信用户客户端。通过本篇博客，将快速上手，从0到1构建起消息推送与发布。一、申请公众号模板消息1、开通微信公众号平台的“模板消息”栏提交申请：添加功能插件>功能详情>申请开通模板接口> 填写业务服务目标所属的行业，申请理由，如果是新申请的消息模板，需要注意规范，否则会被封号的可能！！！.........
Spring Boot打造微信小程序个人健康管理平台
资源摘要信息:"Spring Boot基于微信小程序的个人健康信息管理小程序的实现" 一、技术栈与开发环境 1. Spring Boot: 作为一个开源Java框架，Spring Boot极大地简化了基于Spring的应用开发，使得开发者能够快速搭建...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值