微信小程序—订阅消息开发java完整版，jeecgboot2.4.3后端

本文链接：https://blog.csdn.net/fan9612O_2/article/details/121743952

微信小程序—订阅消息开发java完整版，jeecgboot2.4.3后端。

前言：

1.订阅消息功能，是微信小程序中很常用的功能：使用前提就是先在小程序后台中配置好订阅消息模板。

大体开发流程就是：

小程序后台中配置订阅消息模板——>前端初始化页面时先获取用户登入凭证openid——>用户点击订阅消息，提示是否允许，——>允许以后就可以调用微信接口发送订阅消息了。（正常的模板消息是一次允许一次发送，不允许发送不了用户收不到消息。）

官网文档：
订阅消息接口微信小程序官方文档

一、微信小程序前端调用(订阅消息功能)用户授权：

1.创建index.wxml文件，先来个按钮让用户点。(触发方法：getSubscribeMessage())

<!--pages/subscribeMessage/index.wxml-->
<text>pages/subscribeMessage/index.wxml</text>
<button class="but" bindtap="getSubscribeMessage">订阅消息</button>

2.创建index.js文件，再页面初次渲染完成的方法中先获取openid(微信用户唯一凭证)：

1）准备调用订阅消息接口的数据：

 /**
     * 页面的初始数据
     */
    data: {
        openid:'',
    },
/**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady: function () {
        //调用接口获取登录凭证
        wx.login({
            success: res => {
                //后台获取Openid接口地址：
              let url = 'https://xxxx:8080/api/WxLogin/getOpenid'
              //根据登录凭证获取Openid。
              wx.request({
                url: url,
                data: {
                  code: res.code
                },
                method: 'GET',  
                success: (res)=>{
                  let  records=JSON.parse(res.data.result.body);
                    //存储Openid，为调用订阅消息接口做准备。
                  this.setData({
                    openid:records.openid
                  });
                }
              })    
            }
          })
    },

2）前端申请订阅消息的js方法：

/**
     * 订阅消息申请
     */
    getSubscribeMessage(){
        //官方提供的前端申请订阅消息的js方法：
        wx.requestSubscribeMessage({
            //小程序后台配置的订阅消息的模板id：
            tmplIds: ['订阅消息的模板id'],
            success:(res)=>{
                //用户点击允许。
            wx.request({
                //发送订阅消息接口地址：
                url: 'https://www.xxxx:8080/api/WxLogin/push',
                data: {
                    //传入openid
                 openid: this.data.openid
                },
                method: 'GET',  
                success: (res)=>{
                    wx.showToast({
                        title: '订阅成功！',
                        duration:2000,
                    })
                }
              })    
            },
            fail:(err)=>{
                //用户点击拒绝。
            wx.showToast({
                title: '订阅失败！',
                icon:'error',
                duration:2000,
            })
            }
        })
    },

二、后端处理向允许订阅的用户发送订阅消息：

1.获取openid接口：

 /**微信小程序配置对象：*/
    @Autowired
    WxPayBean wxPayBean;
    /**微信小程序登录凭证校验url：*/
    private static final String code2SessionUrl="https://api.weixin.qq.com/sns/jscode2session";
  /**
     * 获取openid
     * @param code wx.login返回的值
     * @return
     */
    @GetMapping("/getOpenid")
    @ResponseBody
    public Result<?> getOpenid(String code) {
        //组织接口参数：
        JSONObject variables=new JSONObject();
        variables.put("appid", wxPayBean.getAppId());
        variables.put("secret", wxPayBean.getAppSecret());
        variables.put("js_code", code);
        variables.put("grant_type", "authorization_code");
        //System.out.println("toJSONString-->"+variables.toJSONString());
        //发送获取openid请求：
        ResponseEntity<String>  back = RestUtil.request(code2SessionUrl, HttpMethod.GET, null, variables, null, String.class);
        //组织返回数据：
        JSONObject Resultparams=new JSONObject();
        Resultparams.put("body",back.getBody());
        Resultparams.put("appid",wxPayBean.getAppId());
        return Result.OK(Resultparams);
    }

2.向用户发送订阅消息：

/**
     * 向用户发送订阅消息
     * @param openid 微信用户唯一凭证
     * @return
     */
    @GetMapping("/push")
    @ResponseBody
    public  Result<?> push(@RequestParam("openid")String openid) {
        JSONObject variables=new JSONObject();
        variables.put("appid", wxPayBean.getAppId());
        variables.put("secret", wxPayBean.getAppSecret());
        variables.put("grant_type", "client_credential");
        String url = "https://api.weixin.qq.com/cgi-bin/token";
        String result = RestUtil.request(url, HttpMethod.GET, null, variables, null, String.class).getBody().toString();
        JSONObject object = JSONObject.parseObject(result);
        String Access_Token = object.getString("access_token");
        log.info("Access_Token-->",Access_Token);
        //组织模板信息数据(子数据)：
        JSONObject templateData=new JSONObject();
        templateData.put("thing1",getJSONObjectByItem("会员名"));
        templateData.put("thing2",getJSONObjectByItem("大众会员"));
        templateData.put("amount3",getJSONObjectByItem("3000"));
        templateData.put("phone_number4",getJSONObjectByItem("1519999999"));
        templateData.put("thing5",getJSONObjectByItem("会员名的备注"));
		//组织模板凭证数据：
        JSONObject template=new JSONObject();
        template.put("template_id","订阅消息的模板id");
        template.put("touser",openid);
        template.put("page","pages/client/index");//点击订阅消息跳转的小程序页面
        template.put("data",templateData);
        log.info(template.toString());
        String requestUrl = "https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=ACCESS_TOKEN";
        requestUrl = requestUrl.replace("ACCESS_TOKEN", Access_Token);
        log.info("requestUrl-->",requestUrl);
        ResponseEntity<String>  back = RestUtil.request(requestUrl, HttpMethod.POST, null, null, template, String.class);
        if (back != null) {
            log.info(back.getBody().toString());
        }
        return Result.OK(back.getBody());
    }
/**
*创建JSONObject的工程方法：
*/
    public JSONObject getJSONObjectByItem(String val){
        JSONObject templateDataitem=new JSONObject();
        templateDataitem.put("value",val);
        return templateDataitem;
    }

三、备注：

1.后端接口是基于jeecgboot2.4.3写的同用一样后端框架的基本可以直接复制，只需替换小程序配置的参数即可，不是使用jeecgboot的这里只有RestUtil这个工具类不一样，这里给提供一下代码：

其实只用到了：RestUtil.request方法。

package org.jeecg.common.util;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.*;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

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

/**
 * 调用 Restful 接口 Util
 *
 * @author sunjianlei
 */
@Slf4j
public class RestUtil {

    private static String domain = null;

    public static String getDomain() {
        if (domain == null) {
            domain = SpringContextUtils.getDomain();
        }
        return domain;
    }

    public static String path = null;

    public static String getPath() {
        if (path == null) {
            path = SpringContextUtils.getApplicationContext().getEnvironment().getProperty("server.servlet.context-path");
        }
        return oConvertUtils.getString(path);
    }

    public static String getBaseUrl() {
        String basepath = getDomain() + getPath();
        log.info(" RestUtil.getBaseUrl: " + basepath);
        return basepath;
    }

    /**
     * RestAPI 调用器
     */
    private final static RestTemplate RT;

    static {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(3000);
        requestFactory.setReadTimeout(3000);
        RT = new RestTemplate(requestFactory);
        // 解决乱码问题
        RT.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
    }

    public static RestTemplate getRestTemplate() {
        return RT;
    }

    /**
     * 发送 get 请求
     */
    public static JSONObject get(String url) {
        return getNative(url, null, null).getBody();
    }

    /**
     * 发送 get 请求
     */
    public static JSONObject get(String url, JSONObject variables) {
        return getNative(url, variables, null).getBody();
    }

    /**
     * 发送 get 请求
     */
    public static JSONObject get(String url, JSONObject variables, JSONObject params) {
        return getNative(url, variables, params).getBody();
    }

    /**
     * 发送 get 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> getNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.GET, variables, params);
    }

    /**
     * 发送 Post 请求
     */
    public static JSONObject post(String url) {
        return postNative(url, null, null).getBody();
    }

    /**
     * 发送 Post 请求
     */
    public static JSONObject post(String url, JSONObject params) {
        return postNative(url, null, params).getBody();
    }

    /**
     * 发送 Post 请求
     */
    public static JSONObject post(String url, JSONObject variables, JSONObject params) {
        return postNative(url, variables, params).getBody();
    }

    /**
     * 发送 POST 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> postNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.POST, variables, params);
    }

    /**
     * 发送 put 请求
     */
    public static JSONObject put(String url) {
        return putNative(url, null, null).getBody();
    }

    /**
     * 发送 put 请求
     */
    public static JSONObject put(String url, JSONObject params) {
        return putNative(url, null, params).getBody();
    }

    /**
     * 发送 put 请求
     */
    public static JSONObject put(String url, JSONObject variables, JSONObject params) {
        return putNative(url, variables, params).getBody();
    }

    /**
     * 发送 put 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> putNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.PUT, variables, params);
    }

    /**
     * 发送 delete 请求
     */
    public static JSONObject delete(String url) {
        return deleteNative(url, null, null).getBody();
    }

    /**
     * 发送 delete 请求
     */
    public static JSONObject delete(String url, JSONObject variables, JSONObject params) {
        return deleteNative(url, variables, params).getBody();
    }

    /**
     * 发送 delete 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> deleteNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.DELETE, null, variables, params, JSONObject.class);
    }

    /**
     * 发送请求
     */
    public static ResponseEntity<JSONObject> request(String url, HttpMethod method, JSONObject variables, JSONObject params) {
        return request(url, method, getHeaderApplicationJson(), variables, params, JSONObject.class);
    }

    /**
     * 发送请求
     *
     * @param url          请求地址
     * @param method       请求方式
     * @param headers      请求头  可空
     * @param variables    请求url参数 可空
     * @param params       请求body参数 可空
     * @param responseType 返回类型
     * @return ResponseEntity<responseType>
     */
    public static <T> ResponseEntity<T> request(String url, HttpMethod method, HttpHeaders headers, JSONObject variables, Object params, Class<T> responseType) {
        log.info(" RestUtil  --- request ---  url = "+ url);
        if (StringUtils.isEmpty(url)) {
            throw new RuntimeException("url 不能为空");
        }
        if (method == null) {
            throw new RuntimeException("method 不能为空");
        }
        if (headers == null) {
            headers = new HttpHeaders();
        }
        // 请求体
        String body = "";
        if (params != null) {
            if (params instanceof JSONObject) {
                body = ((JSONObject) params).toJSONString();

            } else {
                body = params.toString();
            }
        }
        // 拼接 url 参数
        if (variables != null) {
            url += ("?" + asUrlVariables(variables));
        }
        // 发送请求
        HttpEntity<String> request = new HttpEntity<>(body, headers);
        return RT.exchange(url, method, request, responseType);
    }

    /**
     * 获取JSON请求头
     */
    public static HttpHeaders getHeaderApplicationJson() {
        return getHeader(MediaType.APPLICATION_JSON_UTF8_VALUE);
    }

    /**
     * 获取请求头
     */
    public static HttpHeaders getHeader(String mediaType) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.parseMediaType(mediaType));
        headers.add("Accept", mediaType);
        return headers;
    }

    /**
     * 将 JSONObject 转为 a=1&b=2&c=3...&n=n 的形式
     */
    public static String asUrlVariables(JSONObject variables) {
        Map<String, Object> source = variables.getInnerMap();
        Iterator<String> it = source.keySet().iterator();
        StringBuilder urlVariables = new StringBuilder();
        while (it.hasNext()) {
            String key = it.next();
            String value = "";
            Object object = source.get(key);
            if (object != null) {
                if (!StringUtils.isEmpty(object.toString())) {
                    value = object.toString();
                }
            }
            urlVariables.append("&").append(key).append("=").append(value);
        }
        // 去掉第一个&
        return urlVariables.substring(1);
    }

}