一.开发前准备
- 微信模板消息发送API （建议多看）
- APPID （公众账号appid）
- SECRET（密钥）
- Template_Id（模板ID）
二.代码实现
1. ConfirmTemplate（推送接口）
package com.zero.jimu.utils.pushMessage;
import com.google.gson.Gson;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
public class ConfirmTemplate {
private static Logger logger = LoggerFactory.getLogger(ConfirmTemplate.class);
//微信模板接口
private final String SEND_TEMPLAYE_MESSAGE_URL = "https://api.weixin.qq.com/cgi-bin/message/wxopen/template/send?access_token=ACCESS_TOKEN";//接口地址
private final String APPID = "wx1000000000000000";
private final String SECRET = "ffjshdjhfuis5648156156";
//获取微信ACCESS_TOKEN接口
private final String aturl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + APPID + "&secret=" + SECRET;
//确认模板ID
private static String confirm_template_id="jaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
//取消模板ID
private static String cancel_template_id="Caaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
//拍摄提醒模板ID
private static String push_template_id="6dsadasdasdsadasdsadas";
//商家确认跳转路径及备注信息
private static String confirm_status="商家已确认";
private static String confirm_url="pages/Trip/trip";
private static String confirm_remark = "商家已确认，请及时查看日程";
//商家取消跳转路径及备注信息
private static String cancel_url="pages/index/index";
private static String cancel_remark="非常抱歉，由于该空间当天档期已满，请选好日期和时段重新下单";
//商家超时取消备注信息
private static String cancel_timeout_remark="非常抱歉，由于商家超过规定接单时间未能成功接单，请选好日期和时段重新下单";
private static String cancel_timeout_remark1="非常抱歉，由于您选择的拍摄开始时间已过，商家无法完成正常接单，请选好日期和时段重新下单";
private static String cancel_timeout_remark2="非常抱歉，由于您下的订单为当天拍摄订单，商家未能及时接单，请选好日期和时段重新下单";
/**
* 提醒拍摄推送
* @param openId
* @param form_id
* @param shootDate
* @param shootSite
*/
public void pushRemindMessage(String openId,String form_id,String shootDate,String shootSite){
//获取模板消息接口获取的accessToken
ConfirmTemplate confirmTemplate = new ConfirmTemplate();
AccessTokenDemo demo = confirmTemplate.getAccess_token();
String access_token=demo.getAccess_token();
WechatTemplate wechatTemplate = new WechatTemplate();
wechatTemplate.setTouser(openId); //此处是用户的OpenId
wechatTemplate.setForm_id(form_id);//表单提交场景下，为 submit 事件带上的 formId；支付场景下，为本次支付的 prepay_id
wechatTemplate.setTemplate_id(push_template_id);//所需下发的模板消息的id
wechatTemplate.setPage(confirm_url);//设置小程序跳转路径
//设置模板内容
Map<String,TemplateData> m = new HashMap<>();
TemplateData keyword1 = new TemplateData();
TemplateData keyword2 = new TemplateData();
keyword1.setColor("#000000");
keyword2.setColor("#000000");
keyword1.setValue(shootDate);
keyword2.setValue(shootSite);
m.put("keyword1", keyword1);
m.put("keyword2", keyword2);
wechatTemplate.setData(m);
try {
confirmTemplate.sendTemplateMessage(access_token, wechatTemplate);
} catch (Exception e) {
logger.info("异常"+e.getMessage());
}
}
/**
* 商家确认（取消）订单后，通过微信公众号推送消息给客户
* @param openId
* @param form_id
* @param spaceName
* @param status
* @param payMoney
*/
public void pushMessage(String openId,String form_id,String spaceName,String status,String payMoney){
//获取模板消息接口获取的accessToken
ConfirmTemplate confirmTemplate = new ConfirmTemplate();
AccessTokenDemo demo = confirmTemplate.getAccess_token();
String access_token=demo.getAccess_token();
WechatTemplate wechatTemplate = new WechatTemplate();
wechatTemplate.setTouser(openId); //此处是用户的OpenId
wechatTemplate.setForm_id(form_id);//表单提交场景下，为 submit 事件带上的 formId；支付场景下，为本次支付的 prepay_id
if(status.equals("2")){ //商家确认
wechatTemplate.setTemplate_id(confirm_template_id);//所需下发的模板消息的id
wechatTemplate.setPage(confirm_url);//设置小程序跳转路径
}
if(status.equals("6")||status.equals("8")||status.equals("9")||status.equals("10")){ //商家取消
wechatTemplate.setTemplate_id(cancel_template_id);//所需下发的模板消息的id
wechatTemplate.setPage(cancel_url);//设置小程序跳转路径
}
//设置模板内容
Map<String,TemplateData> m = new HashMap<>();
TemplateData keyword1 = new TemplateData();
TemplateData keyword2 = new TemplateData();
TemplateData keyword3 = new TemplateData();
TemplateData keyword4 = new TemplateData();
keyword1.setColor("#000000");
keyword2.setColor("#000000");
keyword3.setColor("#000000");
keyword4.setColor("#000000");
keyword1.setValue(spaceName);
if(status.equals("2")){ //商家确认
keyword2.setValue(confirm_status);
keyword3.setValue(payMoney);
keyword4.setValue(confirm_remark);
m.put("keyword4", keyword4);
}
if(status.equals("6")){ //商家取消
keyword2.setValue(payMoney);
keyword3.setValue(cancel_remark);
}
if(status.equals("8")){ //商家超时取消
keyword2.setValue(payMoney);
keyword3.setValue(cancel_timeout_remark);
}
if(status.equals("9")){ //下已经过了拍摄开始时间的单子
keyword2.setValue(payMoney);
keyword3.setValue(cancel_timeout_remark1);
}
if(status.equals("10")){ //拍摄时间已过
keyword2.setValue(payMoney);
keyword3.setValue(cancel_timeout_remark2);
}
m.put("keyword1", keyword1);
m.put("keyword2", keyword2);
m.put("keyword3", keyword3);
wechatTemplate.setData(m);
try {
confirmTemplate.sendTemplateMessage(access_token, wechatTemplate);
} catch (Exception e) {
logger.info("异常"+e.getMessage());
}
}
/**
* 推送动作
* @param accessToken
* @param wechatTemplate
*/
public void sendTemplateMessage(String accessToken, WechatTemplate wechatTemplate) {
String jsonString = new Gson().toJson(wechatTemplate).toString();
String requestUrl = SEND_TEMPLAYE_MESSAGE_URL.replace("ACCESS_TOKEN", accessToken);
//logger.info("请求参数",jsonString);//发送 post请求 发送json数据
HttpClientUtil httpClientUtil = new HttpClientUtil();
String json = httpClientUtil.sendHttpPostJson(requestUrl, jsonString);
WeiXinResponse weiXinResponse = new Gson().fromJson(json, WeiXinResponse.class);
//logger.info("jsonObject="+weiXinResponse);
if (null != weiXinResponse) {
int errorCode = weiXinResponse.getErrcode();
if (0 == errorCode) {
//logger.info("模板消息发送成功");
} else {
String errorMsg = weiXinResponse.getErrmsg();
//logger.info("模板消息发送失败,错误是 "+errorCode+",错误信息是"+ errorMsg);
}
}
}
/**
* 获取AccessToken
*/
public AccessTokenDemo getAccess_token() {
try {
String access_token = "";
DefaultHttpClient client = new DefaultHttpClient();
HttpGet request = new HttpGet(aturl);
HttpResponse response = client.execute(request);
HttpClientUtil httpClientUtil = new HttpClientUtil();
String httpGet = httpClientUtil.sendHttpGet(aturl);
Gson gson=new Gson();
AccessTokenDemo jsonResult=new AccessTokenDemo();
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
String strResult = EntityUtils.toString(response.getEntity());
//System.out.println("get请求结果:" + strResult);
//System.out.println("结果回调" +response.getStatusLine().getStatusCode() );
jsonResult = gson.fromJson(strResult, AccessTokenDemo.class);
access_token = jsonResult.getAccess_token();
String expires_in =jsonResult.getExpires_in();
//logger.info("access_token{}: expires_in{}:",access_token,expires_in);
}
return jsonResult;
} catch (ClientProtocolException e) {
//e.printStackTrace();
} catch (IOException e) {
//e.printStackTrace();
} return null;
}
}
2. AccessTokenDemo（微信小程序ACCESS_TOKEN）
package com.zero.jimu.utils.pushMessage;
/**
* 微信小程序ACCESS_TOKEN
*/
public class AccessTokenDemo {
private String access_token;
private String expires_in;
public String getAccess_token() {
return access_token;
}
public void setAccess_token(String access_token) {
this.access_token = access_token;
}
public String getExpires_in() {
return expires_in;
}
public void setExpires_in(String expires_in) {
this.expires_in = expires_in;
}
}
3. HttpClientUtil （http工具类）
package com.zero.jimu.utils.pushMessage;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.DefaultHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.util.PublicSuffixMatcher;
import org.apache.http.conn.util.PublicSuffixMatcherLoader;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.net.URL;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* http工具类
*/
public class HttpClientUtil {
private static Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);
//设置数据传输处理时间、建立连接的timeout时间、从连接池中后去连接的timeout时间
private RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(15000).setConnectTimeout(15000)
.setConnectionRequestTimeout(15000).build();
private boolean checkTimeout = true;
public HttpClientUtil() {
super();
}
/**
* 发送 post请求 发送json数据
*/
public static String sendHttpPostJson(String url, String json) {
// 创建Httpclient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String resultString = "";
try {
// 创建Http Post请求
HttpPost httpPost = new HttpPost(url);
// 创建请求内容
StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
httpPost.setEntity(entity);
// 执行http请求
response = httpClient.execute(httpPost);
resultString = EntityUtils.toString(response.getEntity(), "utf-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return resultString;
}
/**
* 发送 get请求
*
* @param httpUrl
*/
public String sendHttpGet(String httpUrl) {
logger.info("请求sendHttpGet方法，参数httpUrl=" + httpUrl);
HttpGet httpGet = new HttpGet(httpUrl);// 创建get请求
return httpGet(httpGet);
}
/**
* 发送 get请求Https
*
* @param httpUrl
*/
public String sendHttpsGet(String httpUrl) {
logger.info("请求sendHttpsGet方法，参数httpUrl=" + httpUrl);
HttpGet httpGet = new HttpGet(httpUrl);// 创建get请求
return httpsGet(httpGet);
}
/**
* 发送Get请求
*
* @param httpGet
* @return
*/
private String httpGet(HttpGet httpGet) {
//logger.info("请求httpGet方法");
CloseableHttpClient httpClient = null;
CloseableHttpResponse response = null;
HttpEntity entity = null;
String responseContent = null;
try {
// 创建默认的httpClient实例.
httpClient = HttpClients.createDefault();
if (this.checkTimeout)
httpGet.setConfig(requestConfig);
// 执行请求
response = httpClient.execute(httpGet);
entity = response.getEntity();
responseContent = EntityUtils.toString(entity, "UTF-8");
//logger.info("请求httpGet方法响应信息：responseContent=" + responseContent);
} catch (Exception e) {
//logger.error("请求httpGet方法异常，异常信息：" + e.getMessage());
e.printStackTrace();
} finally {
try {
// 关闭连接,释放资源
if (response != null) {
response.close();
}
if (httpClient != null) {
httpClient.close();
}
} catch (Exception e) {
//logger.error("请求httpGet方法，关闭连接异常，异常信息：" + e.getMessage());
e.printStackTrace();
}
}
return responseContent;
}
/**
* 发送Get请求Https
*
* @param httpGet
* @return
*/
private String httpsGet(HttpGet httpGet) {
//logger.info("请求httpsGet方法");
CloseableHttpClient httpClient = null;
CloseableHttpResponse response = null;
HttpEntity entity = null;
String responseContent = null;
try {
// 创建默认的httpClient实例.
PublicSuffixMatcher publicSuffixMatcher = PublicSuffixMatcherLoader
.load(new URL(httpGet.getURI().toString()));
DefaultHostnameVerifier hostnameVerifier = new DefaultHostnameVerifier(publicSuffixMatcher);
httpClient = HttpClients.custom().setSSLHostnameVerifier(hostnameVerifier).build();
if (this.checkTimeout)
httpGet.setConfig(requestConfig);
// 执行请求
response = httpClient.execute(httpGet);
entity = response.getEntity();
responseContent = EntityUtils.toString(entity, "UTF-8");
//logger.info("请求httpsGet方法响应信息：responseContent=" + responseContent);
} catch (Exception e) {
//logger.error("请求httpsGet方法异常，异常信息：" + e.getMessage());
e.printStackTrace();
} finally {
try {
// 关闭连接,释放资源
if (response != null) {
response.close();
}
if (httpClient != null) {
httpClient.close();
}
} catch (Exception e) {
//logger.error("请求httpsGet方法，关闭连接异常，异常信息：" + e.getMessage());
e.printStackTrace();
}
}
return responseContent;
}
/**
* 发送 post请求
*
* @param httpUrl
* 地址
*/
public String sendHttpPost(String httpUrl) {
//logger.info("请求sendHttpPost方法，请求参数httpUrl=" + httpUrl);
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
return httpPost(httpPost);
}
/**
* 发送 post请求
*
* @param httpUrl
* 地址
* @param params
* 参数(格式:key1=value1&key2=value2)
*/
public String sendHttpPost(String httpUrl, String params) {
//logger.info("请求sendHttpPost方法，请求参数httpUrl=" + httpUrl + "，params=" + params);
String responseContent = null;
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
try {
// 设置参数
StringEntity stringEntity = new StringEntity(params, "UTF-8");
stringEntity.setContentType("application/x-www-form-urlencoded");
httpPost.setEntity(stringEntity);
responseContent = httpPost(httpPost);
} catch (Exception e) {
//logger.error("请求sendHttpPost方法异常，异常信息：" + e.getMessage());
e.printStackTrace();
}
return responseContent;
}
/**
* 发送 post请求
*
* @param httpUrl
* 地址
* @param maps
* 参数
*/
public String sendHttpPost(String httpUrl, Map<String, String> maps) {
//logger.info("请求sendHttpPost方法，请求参数httpUrl=" + httpUrl + "，maps=" + maps);
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
// 创建参数队列
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
for (String key : maps.keySet()) {
nameValuePairs.add(new BasicNameValuePair(key, maps.get(key)));
}
try {
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs, "UTF-8"));
} catch (Exception e) {
//logger.error("请求sendHttpPost方法异常，异常信息：" + e.getMessage());
e.printStackTrace();
}
return httpPost(httpPost);
}
/**
* 发送Post请求
*
* @param httpPost
* @return
*/
private String httpPost(HttpPost httpPost) {
//logger.info("请求httpPost方法");
CloseableHttpClient httpClient = null;
CloseableHttpResponse response = null;
HttpEntity entity = null;
String responseContent = null;
try {
// 创建默认的httpClient实例.
httpClient = HttpClients.createDefault();
if (this.checkTimeout)
httpPost.setConfig(requestConfig);
// 执行请求
response = httpClient.execute(httpPost);
entity = response.getEntity();
responseContent = EntityUtils.toString(entity, "UTF-8");
//logger.info("请求httpPost方法响应信息：responseContent=" + responseContent);
} catch (Exception e) {
//logger.error("请求httpPost方法异常，异常信息：" + e.getMessage());
e.printStackTrace();
} finally {
try {
// 关闭连接,释放资源
if (response != null) {
response.close();
}
if (httpClient != null) {
httpClient.close();
}
} catch (Exception e) {
//logger.error("请求httpPost方法，关闭连接异常，异常信息：" + e.getMessage());
e.printStackTrace();
}
}
return responseContent;
}
public String sendHttpsPost(String httpUrl, Map<String, String> maps) {
//logger.info("请求sendHttpsPost方法，参数httpUrl=" + httpUrl + ",maps=" + maps);
String responseContent = null;
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
// 创建参数队列
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
if (null != maps) {
for (String key : maps.keySet()) {
nameValuePairs.add(new BasicNameValuePair(key, maps.get(key)));
}
}
try {
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs, "UTF-8"));
responseContent = httpsPost(httpPost);
} catch (Exception e) {
//logger.error("请求sendHttpPost方法异常，异常信息：" + e.getMessage());
e.printStackTrace();
}
return responseContent;
}
private String httpsPost(HttpPost httpPost) throws Exception {
//logger.info("请求httpsPost方法");
// 采用绕过验证的方式处理https请求
SSLContext sslcontext = createIgnoreVerifySSL();
// 设置协议http和https对应的处理socket链接工厂的对象
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.register("https", new SSLConnectionSocketFactory(sslcontext)).build();
PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
HttpClients.custom().setConnectionManager(connManager);
// 创建自定义的httpclient对象
CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).build();
// 执行请求操作，并拿到结果（同步阻塞）
CloseableHttpResponse response = client.execute(httpPost);
// 获取结果实体
HttpEntity entity = response.getEntity();
String body = "";
if (entity != null) {
// 按指定编码转换结果实体为String类型
body = EntityUtils.toString(entity, "UTF-8");
}
//logger.info("请求httpsPost方法响应信息：body=" + body);
EntityUtils.consume(entity);
// 释放链接
response.close();
return body;
}
/**
* 绕过验证
*
* @return
* @throws Exception
*/
private SSLContext createIgnoreVerifySSL() throws Exception {
SSLContext sc = SSLContext.getInstance("SSL");
// 实现一个X509TrustManager接口，用于绕过验证，不用修改里面的方法
X509TrustManager trustManager = new X509TrustManager() {
@Override
public void checkClientTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
String paramString) throws CertificateException {
}
@Override
public void checkServerTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
String paramString) throws CertificateException {
}
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return null;
}
};
sc.init(null, new TrustManager[] { trustManager }, null);
return sc;
}
/**
* 是否校验超时时间
*
* @return true：校验<br>
* false：不校验(默认)
*/
public boolean isCheckTimeout() {
return checkTimeout;
}
/**
* 设置是否校验超时时间
*
* @param checkTimeout
* true：校验<br>
* false：不校验(默认)
*/
public void setCheckTimeout(boolean checkTimeout) {
this.checkTimeout = checkTimeout;
}
}
4. TemplateData
package com.zero.jimu.utils.pushMessage;
/**
* 模板消息Template数据封装
*/
public class TemplateData {
private String value;
private String color;//模板内容字体的颜色，不填默认黑色 【废弃】
public TemplateData() {
super();
}
public TemplateData(String value, String color) {
this.value = value;
this.color = color;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
5. WechatTemplate
package com.zero.jimu.utils.pushMessage;
import java.util.Map;
/**
* 发送模版消息post参数封装
*/
public class WechatTemplate {
private String touser;//接收者（用户）的 openid
private String template_id;//所需下发的模板消息的id
private String page;//点击模板卡片后的跳转页面，仅限本小程序内的页面。支持带参数,（示例index?foo=bar）。该字段不填则模板无跳转。
private String form_id;//表单提交场景下，为 submit 事件带上的 formId；支付场景下，为本次支付的 prepay_id
private String emphasis_keyword;//模板需要放大的关键词，不填则默认无放大
private Map<String, TemplateData> data;//模板内容，不填则下发空模板
public WechatTemplate() {
super();
}
public WechatTemplate(String touser, String template_id, String page, String form_id, String emphasis_keyword, Map<String, TemplateData> data) {
this.touser = touser;
this.template_id = template_id;
this.page = page;
this.form_id = form_id;
this.emphasis_keyword = emphasis_keyword;
this.data = data;
}
public String getTouser() {
return touser;
}
public void setTouser(String touser) {
this.touser = touser;
}
public String getTemplate_id() {
return template_id;
}
public void setTemplate_id(String template_id) {
this.template_id = template_id;
}
public String getPage() {
return page;
}
public void setPage(String page) {
this.page = page;
}
public String getForm_id() {
return form_id;
}
public void setForm_id(String form_id) {
this.form_id = form_id;
}
public String getEmphasis_keyword() {
return emphasis_keyword;
}
public void setEmphasis_keyword(String emphasis_keyword) {
this.emphasis_keyword = emphasis_keyword;
}
public Map<String, TemplateData> getData() {
return data;
}
public void setData(Map<String, TemplateData> data) {
this.data = data;
}
}
6. WeiXinResponse
package com.zero.jimu.utils.pushMessage;
/**
* 微信返回错误信息
*/
public class WeiXinResponse {
private Integer errcode;
private String errmsg;
private String msgid;
public Integer getErrcode() {
return errcode;
}
public void setErrcode(Integer errcode) {
this.errcode = errcode;
}
public String getErrmsg() {
return errmsg;
}
public void setErrmsg(String errmsg) {
this.errmsg = errmsg;
}
public String getMsgid() {
return msgid;
}
public void setMsgid(String msgid) {
this.msgid = msgid;
}
}
422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
