微信公众号实现消息推送

最新推荐文章于 2024-09-14 10:29:23 发布
最新推荐文章于 2024-09-14 10:29:23 发布
阅读量1.8k 收藏 2
点赞数 2
分类专栏： 问题总结 学习 文章标签： 微信公众号 消息推送
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NB6063/article/details/90481075
版权 
public JsonResult sendMessage(String content) {

        //获得令牌
//        String accessToken = "21_UrWTu7IQt5N5KFlnPRdI4ec4C3vPxyvchJQf5E-yBmFED-uEeT6CF5eLpj9yFY6wloZAP6bYmCBR784_wACmU_MZX70JzumXu7XjT58ykCSNkDUW1qFh3JgJ7qJAtLBuwXDhEAbLYZIEF9cmCUVcAGAOGH";
        WxAccesstoken wxAccesstoken = wxAccesstokenMapper.selectByPrimaryKey("E1C969101C0000008E00000000366000");
        String accessToken = wxAccesstoken.getAccessToken();

        String url = TemplateMessage_Url.replace("ACCESS_TOKEN",accessToken);
        //调用接口进行发送
        try {
            Map<String, String> headers = new HashMap<>();
            headers.put("Content-Type","application/json;charset=utf-8");
            HttpResponse res = HttpUtils.doPost2(url,"",null,headers,null, content);
            String returnJson = EntityUtils.toString(res.getEntity());
            return JsonResult.success(returnJson);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

 

工具类

package com.zt.oa.util;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpUtils {

    /**
     * get
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, Object> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    /**
     * post form
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, Object> querys,
                                      Map<String, String> bodys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (bodys != null) {
            List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }

        return httpClient.execute(request);
    }

    /**
     * Post String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, Object> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body.toString().indexOf(" ")<0 /*StringUtils.isNotBlank(body)*/) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }


    /**
     * Post String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost2(String host, String path, String method,
                                       Map<String, String> headers,
                                       Map<String, Object> querys,
                                       String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        request.setEntity(new StringEntity(body, "utf-8"));

        return httpClient.execute(request);
    }

    /**
     * Post stream
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, Object> querys,
                                      byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Put String
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, Object> querys,
                                     String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body.toString().indexOf(" ")<0/*StringUtils.isNotBlank(body)*/) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Put stream
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, Object> querys,
                                     byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Delete
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path, String method,
                                        Map<String, String> headers,
                                        Map<String, Object> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    private static String buildUrl(String host, String path, Map<String, Object> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (path.toString().indexOf(" ")<0/*!StringUtils.isBlank(path)*/) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, Object> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (query.getKey().indexOf(" ")>0/*StringUtils.isBlank(query.getKey())*/ &&String.valueOf(query.getValue()).indexOf(" ")<0 /*!StringUtils.isBlank(query.getValue())*/) {
                    sbQuery.append(query.getValue());
                }
                if (query.getKey().indexOf(" ")>0/*!StringUtils.isBlank(query.getKey())*/) {
                    sbQuery.append(query.getKey());
                    if (String.valueOf(query.getValue()).indexOf(" ")<0/*!StringUtils.isBlank(query.getValue())*/) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(String.valueOf(query.getValue()), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }

        return sbUrl.toString();
    }

    private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }

        return httpClient;
    }

    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                public void checkClientTrusted(X509Certificate[] xcs, String str) {

                }
                public void checkServerTrusted(X509Certificate[] xcs, String str) {

                }
            };
            ctx.init(null, new TrustManager[] { tm }, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }
}

测试controller

 /**
     * 测试
     * @return
     */
    @GetMapping("/sendTest")
    public JsonResult testSendMessage(){

        //创建消息发送实体对象
        TemplateMessage templateMessage=new TemplateMessage();
//        templateMessage.setUrl("www.baidu.com");
        templateMessage.setTouser("oZ5gZ000ftRiKIbZplGit8x0f_M0");
        templateMessage.setTemplate_id(templateId);
        //设置模板标题
        Content first=new Content();
        first.setValue("您好！您发起了流程审批");
        first.setColor("#000");
        //设置模板内容
        Content keyword1=new Content();
        keyword1.setValue("尹东伟发起的车采购审批");
        keyword1.setColor("#000");
        //设置模板位置
        Content keyword2=new Content();
        keyword2.setValue("发起");
        keyword2.setColor("#000");
        //设置设备
        Content keyword3=new Content();
        keyword3.setValue("尹东伟");
        keyword3.setColor("#000");
        //设置时间
        Content keyword4=new Content();
        SimpleDateFormat format=new SimpleDateFormat("yyyy年MM月dd日");
        String format1 = format.format(new Date());
        keyword4.setValue(format1);
        keyword4.setColor("#000");
        //设置跳转内容
        Content remark=new Content();
        remark.setValue("请您及时关注流程动态");
        remark.setColor("#000");
        //创建模板信息数据对象
        Data data=new Data();
        data.setFirst(first);
        data.setKeyword1(keyword1);
        data.setKeyword2(keyword2);
        data.setKeyword3(keyword3);
        data.setKeyword4(keyword4);
        data.setRemark(remark);
        templateMessage.setData(data);
        //将封装的数据转成JSON
        String jsonString = JSON.toJSONString(templateMessage);
        logger.info(jsonString);
        JsonResult jsonResult = wxMessageService.sendMessage(jsonString);

        return jsonResult;
    }

 

举头忘明月
关注
专栏目录
实战：Python+微信公众号，轻松实现固定格式的消息定向推送
同学小张的博客
01-22 1323
Python+微信公众号，轻松实现固定格式的消息定向推送
微信公众号每日消息推送天气给女朋友制作教程
10-09
给女朋友做的微信公众号消息每日自动推送天气及纪念日通知教程，该教程为github每日自动线上运行版本。本人亲测妹子很喜欢~女孩子都喜欢这种用心做的东西！ 1.最新版本 成品 +源码 +消息模板 （需要自己申请 天行 ...
微信公众号信息推送——详细版
ENTIRYD的博客
05-20 3081
基本天气推送——实时定位、信息推送、天气状况ChatGpt聊天——OpenAi接口。
微信小程序开通消息推送
大魔王的博客
09-14 795
URL(服务器地址)：必须以http://或https://开头，分别支持80端口和443端口，填写接口路径。token自己随便定义（必须为英文或数字，长度为3-32字符），待会要配置到消息推送的配置中。appId和appSecret都可以从公众平台上获取，在开发管理-开发者ID里面。AccessToken：可以参考 微信工具类getAccessToken()方法。若是URL和Token填写不正确，会提交不了。Token：就刚刚项目中配置的token。
微信公众号消息推送
haijun1993的博客
09-12 527
发消客户息微信官网文档地址：https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421140547 发送模版消息信官网文档地址：https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1433751277 推送单个人文本消息 请求URL：https://ap...
微信公众号消息推送教程
程序员凯小白的博客
09-03 1万+
微信每日消息推送
springboot实现微信公众号模版消息推送
07-09
springboot实现微信公众号模版消息推送，用的是构架：springboot+redis,详细教程：https://blog.csdn.net/chenhongming888/article/details/95173079
dotnet-DotNETCore实现微信公众号被关注时推送消息
06-01
dotnet-DotNETCore实现微信公众号被关注时推送消息dotnet-DotNETCore实现微信公众号被关注时推送消息dotnet-DotNETCore实现微信公众号被关注时推送消息dotnet-DotNETCore实现微信公众号被关注时推送消息dotnet-...
java实现微信公众号模版消息推送
06-08
java二次开发接微信公众号接口，实现根据用户授权，获取用户code，再获取openid，然后向其推送模版消息
微信公众号模板消息推送代码
04-22
微信公众号模板消息推送代码，亲测可行。其中有一个工具类，注释啥的都有。需要的可以看看
asp.net 实现微信公众平台的主动推送信息源码
12-31
微信公众帐号主动发送消息给用户，asp.net版本
ASP.NET WEB端消息推送源码
04-19
ASP.NET WEB端消息推送源码,可以推送到手机端，包括Android ,IOS
asp.net 微信公众号开发源码
04-12
asp.net 微信公众号开发源码
微信公众号开发（二、消息推送）
热门推荐
i_Sing的博客
08-05 1万+
微信公众号的配置完了，消息推送就比较简单了。本节主要介绍一下推送的代码。          一、首先需要在公众号平台中新建一个模板（用于推送消息）。下面是测试和正式微信公众号的模板。正式的模板可以设置标题、行业、内容以及备注等等。注意：如果是新申请的微信公众号，模板需要申请，大概需要一两天时间。         二、模板消息推送         首先是根据Access Token
微信公众号怎么推送消息_微信公众号发送消息
weixin_34122548的博客
07-23 516
微信公众号分为订阅号和服务号，订阅号每天可以推送一条消息，服务号由之前的每月推送一条改为每个自然月可以推送四条消息，并且关注的用户最多可以接收四条消息每个月。那么微信公众号怎么推送消息呢？可能很多朋友还不是太清楚，下面就来为朋友们介绍一下微信公众号怎么推送消息。   工具/原料 电脑 微信公众号 ...
SpringBoot(JAVA)整合微信公众号消息推送
weixin_46204877的博客
07-12 3201
在使用JAVA(springboot)开发微信公众号时,有时需要向微信服务器上传一些临时素材,比如图片、语音、视频等。本文将介绍如何实现JAVA微信新增临时素材的功能
【微信公众号推送小程序消息通知】--下发统一消息接口被回收后新方案
weixin_43566316的博客
11-08 5633
由于微信小程序长期订阅的消息模板和下发统一消息推送接口全部失效以后，对于小程序的消息推送可以往公众号推可以使用本文章方案。3、公众号根据想要的模板消息绑定服务类目，去模板消息中先挑选你的模板消息。（如果是刚注册的公众号还需要去新的功能页面添加模板消息功能，需要微信审核，不过很快）接口的时候会返回unionid，这个unionid就是推送的关键。（订阅号是不可以推送的）与小程序，两者都需要认证并且。通过在开放平台绑定的公众号与小程序后，我们在调用微信。注册账号（该账号也需要认证），绑定小程序与公众号。
完整开发实现公众号主动消息推送，精彩内容即刻到达
黑夜开发者的博客
09-01 5349
公众号是企业与用户之间进行交互和传播信息的重要工具。在一些特定的场景中，我们可能需要给用户进行不限制次数的消息推送，以保持用户对公众号的关注和互动。本文将介绍如何使用PHP开发实现微信公众号主动推送消息的功能，并逐步指导您完成相关配置和开发的步骤。本文所使用到的是服务号，为了确保使用到更加完善的功能，建议通过企业服务号来进行推送。
微信公众号实现消息推送实现代码
最新发布
10-01
微信公众号的消息推送通常通过微信提供的开发者API来完成，主要包括以下几个步骤： 1. **注册并获取appid**: 首先需要在微信公众平台上注册一个公众号，并获得AppID。 2. **安装微信开放平台SDK**: 下载微信开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值