热门标签
热门文章
- 1verilog之状态机详细解释（一）_状态机verilog
- 2python实现bisect_left()和bisect_right()_bisect_right函数参数
- 3浅入浅出TensorFlow 7 - 行人检测之Faster-RCNN_faster r-cnn行人检测
- 4Python使用PooledDB连接池连接Mysql_python pooleddb
- 5centos7安装mongodb
- 6nginx小技巧-动态域名(微信，小程序80端口)
- 7Liblinphone 3.9.1中文--Modules--Managing proxies_linphone_proxy_config_enable_register
- 8016—pandas 分析近100年圣诞节日期分布
- 9Python版—力扣hot100
- 10用code去探索理解Llama架构的简单又实用的方法
当前位置: article > 正文
小程序发送模板消息给用户 —— 一次性模板实现“长期订阅”_小程序模板消息
作者：你好赵伟 | 2024-02-19 06:19:26
赞
踩
小程序模板消息
大家好！我是我玩亚索我会C，在写小程序时，我们会有向用户发送消息的需求，比如发送提醒通知，或者是一些重要通知来形成一个服务的闭环。这就要用到微信的发送消息功能了，下面我使用Java语言来详细演示下如何使用一次性订阅消息发送消息给用户。
1.微信发消息流程
因为微信算是比较正式的社交软件，主动向用户发信息这个动作很容易被一些商家作为推销的手段，为了避免用户被骚扰所以就由用户直接来决定是否要接受该消息，这样设计很不错！
2.订阅消息
2.1 消息模板
发送消息必须使用微信小程序官方提供的消息模板。消息模板可以在微信公众号平台获取（前提是你得注册过了），如下图：
选好模板后，点击操作栏的选用按钮即可。如下图：
2.1.1 消息内容说明：
（1）模板id： 模板的唯一标识，微信小程序端和服务器端都需使用，来确定使用那个模板。
（2）详细内容： 这里就是消息的内容，上图所示中的 温馨提示 就是标题，{{ting6.DATA}}就是值。
剩余模板中的内容都不重要，在此不作赘述。
2.2 消息类型
（1）一次性订阅：用户自主订阅后，可不限时间地下发一条对应的服务消息；每次订阅只能发送一条消息。
（2）长期订阅：用户订阅一次后，可长期下发多条消息。长期订阅对资质的要求很高，目前长期性订阅消息仅向政务民生、医疗、交通、金融、教育等线下公共服务开放，后期将逐步支持到其他线下公共服务业务。本文选用的时一次性订阅。
2.3 消息发送
（1）方法：wx.requestSubscribeMessage(Object object)（微信官方文档入口）该wx.requestSubscribeMessage()用在微信小程序端，用于调起订阅消息界面。如下图：
2.3.1 注意事项：
（1）触发方式： wx.requestSubscribeMessage(Object object)只能用于点击按钮触发。
（2）一次性消息： 在消息类型中提及到，一次性订阅消息在用户自主订阅后，只能发送一次消息。
3.前端端代码
3.1 前端代码
（1）前端Html代码：
...
//由点击事件调出订阅消息界面
<button bindtap="subScriptionMessage"></button>
...
- 1
- 2
- 3
- 4
（2） 前端JS代码：
...
//调出 模板消息界面
subScriptionMessage(){
wx.requestSubscribeMessage({
//模板id，可以写多个
tmplIds:['sn12-c51f_1PCY52t0u5UZbqKaS7z4G7U1mV-4ZH']
//成功回调
success(res){
console.log(res);
},
//失败回调
fail(res){
console.log(res);
}
})
}
...
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
3.2 后端代码
（1）代码
import lombok.extern.slf4j.Slf4j;
//微信小程序id
private final String appId = "xxx";
//微信小程序密钥
private final String appSecret = "xxx";
//模板id
private final String templateId = "xxx";
//用户openid
private final String openUserId = "xxxx";
//消息内容-温馨提示
private final String warmTip = "hello,tough gay!";
//跳转页面地址
private final String pageUrl = "pages/index/index";
//获取token接口
private final String getTokenUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid="+ appId + "&secret=" + appSecret;
//发送消息接口
private final String sendWxUserMsgUrl = "https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=";
public void sendMessage(){
//获取token
String accessTokenResult = HttpClientUtil.doGet(getTokenUrl);
String accessToken = JSONObject.parseObject(accessTokenResult).getString("access_token");
SendMsgToWxUserRequestDTO sendMsgToWxUserRequestDTO = new SendMsgToWxUserRequestDTO();
sendMsgToWxUserRequestDTO.setAccessToken(accessToken);
sendMsgToWxUserRequestDTO.setTouser(openUserId);
sendMsgToWxUserRequestDTO.setTemplate_id(templateId);
JSONObject key = new JSONObject();
//温馨提醒
JSONObject thing6OfValue = new JSONObject();
thing6OfValue.put("value",warmTip);
key.put("thing6",thing6OfValue);
//当前时间
JSONObject time2 = new JSONObject();
time2.put("value", DateUtil.dateToString(new Date(),DateUtil.DATETIME_FORMATTER));
key.put("time2",time2);
sendMsgToWxUserRequestDTO.setData(key);
sendMsgToWxUserRequestDTO.setPage(pageUrl);
String sendMessageUrl = sendWxUserMsgUrl + accessToken;
log.info("发送消息参数:{}",JSONObject.toJSONString(sendMsgToWxUserRequestDTO));
String s = HttpClientUtil.doPost(sendMessageUrl, JSONObject.toJSONString(sendMsgToWxUserRequestDTO));
log.info("发送消息参数,返回值:{}",s);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
SendMsgToWxUserRequestDTO 类：
import com.alibaba.fastjson.JSONObject;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class SendMsgToWxUserRequestDTO {
/**
* token
*/
private String accessToken;
/**
* 接收方openId
*/
private String touser;
private String template_id;
private String page;
/**
* 小程序模板数据
*/
private Object data;
private String miniprogram_state;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
DateUtil类：
package com.hjd.task.common.utils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.regex.Pattern;
@Slf4j
public class DateUtil extends DateUtils {
/**
* 日期格式
*/
public static final String DATE_FORMATTER = "yyyy-MM-dd";
/**
* 日期格式无分割
*/
public static final String DATE_FORMATTER_NO_SEGMENTATION = "yyyyMMdd";
public static final String DATETIME_FORMATTER_NO_SEGMENTATION = "yyyyMMddHHmmss";
/**
* 时间格式
*/
public static final String DATETIME_FORMATTER = "yyyy-MM-dd HH:mm:ss";
/**
* 日期小时
*/
public static final String DATE_HOUR_FORMATTER = "yyyy-MM-dd HH:mm";
/**
* 小时分钟
*/
public static final String DATE_HOUR_STR_FORMATTER = "HH点mm分";
/**
* 小时分钟
*/
public static final String HOUR_MINUTE_FORMATTER = "HH:mm";
public static final String DATE_FORMATTER_NO_HMS = "yyyyMMdd";
/**
* 日期月份
*/
public static final String DATE_MONTH_FORMATER = "yyyy-MM";
/**
* 年
*/
public static final String YEAR_FORMATTER = "yyyy";
/**
* 月
*/
public static final String MONTH_FORMATTER = "MM";
/**
* 中国标准时间
* edg: Thu Feb 02 00:00:00 WET 2012.
*/
public static final String DATE_EEE_FORMATER = "EEE MMM dd HH:mm:ss zzz yyyy";
/**
* 日期带开始时间'T'格式
*/
public static final String DATE_T_FORMATER = "yyyy-MM-dd'T'HH:mm:ss";
/**
* 转成中文日期
*/
public static final String DATE_STR_FORMATER = "yyyy年MM月dd日";
/**
* 日期时间字符串格式
*/
public static final String DATETIME_STR_FORMATTER = "yyyy年MM月dd日 HH时mm分";
/**
* 日期字符串格式
*/
public static final String DATE_STR_FORMATTER = "yyyy年MM月dd日";
/**
* 月日字符串格式
*/
public static final String MONTH_DATE_FORMATTER = "MM月dd日";
/**
* 月日字符串格式
*/
public static final String MONTH_DATE_SHORT_FORMATTER = "M月d日";
/**
* 月日时间字符串格式
*/
public static final String MONTH_DATE_TIME_FORMATTER = "M月d日HH:mm";
/**
* 年/月/日 字符串格式
*/
public static final String YEAR_MONTH_DATE_FORMATTER = "yyyy/MM/dd";
/**
* 今天的最后时间
*/
public static final String NOW_END_TIME = "yyyy-MM-dd 23:59:59";
/**
* 今天的开始时间
*/
public static final String NOW_START_TIME = "yyyy-MM-dd 00:00:00";
/**
* 一天的毫秒数
*/
public static final Long DAY_MILLISECONDS = 86400000L;
/**
* 时间进制
*/
public static final Integer DAY_RADIX = 24;
public static final Integer TIME_RADIX = 60;
public static final Integer MILLISECONDS_RADIX = 1000;
public static final Long TWO_HOURS = 7200000L;
public static final Long ONE_DAY = 86400000L;
public static final long nd = 1000 * 24 * 60 * 60;
public static final long nh = 1000 * 60 * 60;
public static final long nm = 1000 * 60;
/**
* 获取两个日期相差的月数
*
* @param startDate 开始日期
* @param endDate 结束日期
* @return 如果d2>d1返回 月数差 否则返回0
*/
public static int getMonthDiff(Date startDate, Date endDate) {
if (endDate == null || startDate == null) {
return 0;
}
Calendar c1 = Calendar.getInstance();
Calendar c2 = Calendar.getInstance();
c1.setTime(endDate);
c2.setTime(startDate);
if (c1.getTimeInMillis() < c2.getTimeInMillis()) {
return 0;
}
int year1 = c1.get(Calendar.YEAR);
int year2 = c2.get(Calendar.YEAR);
int month1 = c1.get(Calendar.MONTH);
int month2 = c2.get(Calendar.MONTH);
int day1 = c1.get(Calendar.DAY_OF_MONTH);
int day2 = c2.get(Calendar.DAY_OF_MONTH);
// 获取年的差值 假设 d2 = 2015-8-16 d1 = 2011-9-30
int yearInterval = year1 - year2;
// 如果 d2的 月-日 小于 d1的 月-日 那么 yearInterval-- 这样就得到了相差的年数
if (month1 < month2 || month1 == month2 && day1 < day2) {
yearInterval--;
}
// 获取月数差值
int monthInterval = (month1 + 12) - month2;
if (day1 < day2) {
monthInterval--;
}
monthInterval %= 12;
return yearInterval * 12 + monthInterval;
}
/**
* 比较两个时间相差的天数
*
* @param beginDate
* @param endDate
* @return
*/
public static Long getDaysDiff(LocalDate beginDate, LocalDate endDate) {
return endDate.toEpochDay() - beginDate.toEpochDay();
}
/**
* 比较两个时间相差的天数
*
* @param startDate
* @param endDate
* @return
*/
public static Long getDaysDiff(Date startDate, Date endDate) {
if(ObjectUtils.isEmpty(startDate) || ObjectUtils.isEmpty(endDate)){
return null;
}
LocalDate beginTime = DateUtil.getDateToLocalDate(startDate);
LocalDate endTime = DateUtil.getDateToLocalDate(endDate);
return getDaysDiff(beginTime, endTime);
}
/**
* 计算两个时间相差的秒数
* @param startTime
* @param endTime
* @return
* @throws ParseException
*/
public static long getSecondDiff(String startTime, String endTime){
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long eTime = 0;
long sTime = 0;
try {
eTime = df.parse(endTime).getTime();
sTime = df.parse(startTime).getTime();
} catch (ParseException e) {
e.printStackTrace();
}
long diff = (eTime - sTime) / 1000;
return diff;
}
/**
* 获取相差月份时的时间
*
* @param date 日期
* @param month 距date 相差月份 正数加 负数减
* @return
*/
public static String getMonthByDate(Date date, int month, String formatter) {
if (StringUtils.isEmpty(formatter)) {
formatter = DATETIME_FORMATTER;
}
return dateToString(getDifferInByDate(date, month), formatter);
}
/**
* 获取相差月份时的时间
*
* @param date 日期
* @param month 距date 相差月份 正数加 负数减
* @return
*/
public static Date getDifferInByDate(Date date, int month) {
if (date == null) {
return null;
}
Calendar c = Calendar.getInstance();
c.setTime(date);
c.add(Calendar.MONTH, month);
Date m = c.getTime();
return m;
}
/**
* 获取localDate日期的开始时间 {@link java.time.LocalTime}
* eg. 2018-06-11 13:31:31 return 2018-06-11 00:00:00
*
* @param localDate
* @return
* @author wangfuguo
*/
public static Date getDateBeginTime(LocalDate localDate) {
LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.MIN);
ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.systemDefault());
return Date.from(zonedDateTime.toInstant());
}
/**
* 获取localDate日期的结束时间 {@link java.time.LocalTime}
* eg. 2018-06-11 13:31:31 return 2018-06-11 23:59:59.999999999
*
* @param localDate
* @return
* @author wangfuguo
*/
public static Date getDateEndTime(LocalDate localDate) {
LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.MAX);
ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.systemDefault());
return Date.from(zonedDateTime.toInstant());
}
/**
* 获取localDate日期的结束时间 {@link LocalTime}
* eg. 2018-06-11 13:31:31 return 2018-06-11 23:59:59.000
*
* @param localDate
* @return
* @author leigang
*/
public static Date getEndTimeOfDay(LocalDate localDate) {
LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.of(23, 59, 59, 0));
ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.systemDefault());
return Date.from(zonedDateTime.toInstant());
}
/**
* 获取dateTime 的开始时间
* @return
*/
public static Date getStartTimeDay(Date dateTime){
try {
String format = DateFormatUtils.format(dateTime, NOW_START_TIME);
Date endTime = DateUtils.parseDate(format, DATETIME_FORMATTER);
return endTime;
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
/**
* 获取dateTime 的结束时间
* @return
*/
public static Date getEndTimeDay(Date dateTime){
try {
String format = DateFormatUtils.format(dateTime, NOW_END_TIME);
Date endTime = DateUtils.parseDate(format, DATETIME_FORMATTER);
return endTime;
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
/**
* 获取localDate日期的中午12.00{{@link java.time.LocalTime}
* eg 2019-03-28 14:32.36 retrun 2019-03-28 12:00:00
*
* @param localDate
* @return
* @author wugucheng
*/
public static Date getDateNoon(LocalDate localDate) {
LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.NOON);
ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.systemDefault());
return Date.from(zonedDateTime.toInstant());
}
/**
* date 转 LocalDate
*
* @param date
* @return
*/
public static LocalDate dateToLocalDate(Date date) {
Instant instant = date.toInstant();
ZoneId zone = ZoneId.systemDefault();
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
return localDateTime.toLocalDate();
}
/**
* 获取localDate日期所在月的开始日期
* eg. 2018-06-11 13:31:31 return 2018-06-01 00:00:00
*
* @param localDate
* @return
* @author wangfuguo
*/
public static Date getMonthFirstDay(LocalDate localDate) {
LocalDate firstDate = localDate.with(TemporalAdjusters.firstDayOfMonth());
return getDateBeginTime(firstDate);
}
/**
* 获取localDate日期所在月的结束日期
* eg. 2018-06-11 13:31:31 return 2018-06-30 23:59:59.999999999
*
* @param localDate
* @return
* @author wangfuguo
*/
public static Date getMonthLastDay(LocalDate localDate) {
LocalDate firstDate = localDate.with(TemporalAdjusters.lastDayOfMonth());
return getDateEndTime(firstDate);
}
/**
* 获取localDate日期所在年的开始日期
* eg. 2018-06-11 13:31:31 return 2018-06-01 00:00:00
*
* @param localDate
* @return
* @author leiGang
*/
public static Date getYearFirstDay(LocalDate localDate) {
LocalDate firstDate = localDate.with(TemporalAdjusters.firstDayOfYear());
return getDateBeginTime(firstDate);
}
/**
* 日期转字符串
*
* @param date
* @param formatter
* @return
*/
public static String dateToString(Date date, String formatter) {
if (date == null) {
return null;
}
if (StringUtils.isEmpty(formatter)) {
formatter = DATETIME_FORMATTER;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter);
return simpleDateFormat.format(date);
}
/**
* 日期转字符串
*
* @param date
* @param formatter
* @return
*/
public static String dateToStringStr(Date date, String formatter) {
if (date == null) {
return null;
}
if (StringUtils.isEmpty(formatter)) {
formatter = DATE_STR_FORMATER;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter);
return simpleDateFormat.format(date);
}
/**
* 毫秒值转日期
*
* @param time
* @param formatter
* @return
*/
public static Date timeMillisToDate(long time, String formatter) {
if (time == 0) {
return null;
}
if (StringUtils.isEmpty(formatter)) {
formatter = DATETIME_FORMATTER;
}
try {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter);
Date date = new Date();
date.setTime(time);
return date;
} catch (Exception e) {
log.error("毫秒值转日期错误!", e);
return null;
}
}
/**
* 字符串转日期
*
* @param dateString
* @param formatter
* @return
*/
public static Date stringToDate(String dateString, String formatter) {
if (StringUtils.isEmpty(dateString)) {
return null;
}
if (StringUtils.isEmpty(formatter)) {
formatter = DATETIME_FORMATTER;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter);
try {
return simpleDateFormat.parse(dateString);
} catch (ParseException e) {
log.error("字符串转日期错误!", e);
return null;
}
}
/**
* CST字符串转日期
*
* @param dateString
* @param formatter
* @return
*/
public static Date stringCSTToDate(String dateString, String formatter) {
if (StringUtils.isEmpty(dateString)) {
return null;
}
if (StringUtils.isEmpty(formatter)) {
formatter = DATE_EEE_FORMATER;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter, Locale.US);
try {
return simpleDateFormat.parse(dateString);
} catch (ParseException e) {
log.error("字符串转日期错误!", e);
return null;
}
}
/**
* java.util.Date --> java.time.LocalDate
*/
public static LocalDate getDateToLocalDate(Date date) {
Instant instant = date.toInstant();
ZoneId zone = ZoneId.systemDefault();
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
return localDateTime.toLocalDate();
}
/**
* 比较
*
* @param startTime endTime
* @return
* @Author wugucheng
*/
public static Long compare(Date startTime, Date endTime) {
return endTime.getTime() - startTime.getTime();
}
/**
* 得到两日期之间的毫秒数
*
* @param date1
* @param date2
* @return
*/
public static long subDate(Date date1, Date date2) {
if (date1 == null || date2 == null) {
return 0;
}
return date1.getTime() - date2.getTime();
}
/**
* 计算已用耗时小时
*
* @param date1
* @param date2
* @return
*/
public static Long getTwoDateHour(Date date1, Date date2) {
return getTwoDateTotalMin(date1, date2) / TIME_RADIX;
}
/**
* 计算已用耗时分钟
*
* @param date1
* @param date2
* @return
*/
public static Long getTwoDateMin(Date date1, Date date2) {
return getTwoDateTotalMin(date1, date2) % TIME_RADIX;
}
/**
* 获取两个时间之间的分钟数
*
* @param date1
* @param date2
* @return
*/
public static long getTwoDateTotalMin(Date date1, Date date2) {
if (date1 == null || date2 == null) {
return 0L;
}
long timeMils = date1.getTime() - date2.getTime();
return timeMils / (MILLISECONDS_RADIX * TIME_RADIX);
}
/**
* 根据分钟获取小时和分钟
*
* @param min
* @return
*/
public static String getHourAndMin(Long min) {
if (min == null || min <= 0) {
return "0小时0分";
}
return min / TIME_RADIX + "小时" + min % TIME_RADIX + "分钟";
}
/**
* 根据毫秒计算天数(向上取整)
*
* @param milliseconds
* @return
*/
public static Long getDaysByMillisecondsCeil(Long milliseconds) {
if (milliseconds == null) {
return null;
}
Long radix = (long) DAY_RADIX * (long) TIME_RADIX * (long) TIME_RADIX * (long) MILLISECONDS_RADIX;
if (milliseconds % radix != 0) {
return milliseconds / radix + 1;
}
return milliseconds / radix;
}
/**
* 判断是否是同一年
*
* @param date1
* @param date2
* @return
*/
public static boolean isSameYear(Date date1, Date date2) {
if (date1 == null || date2 == null) {
throw new IllegalArgumentException("The date must not be null");
}
Calendar cal1 = Calendar.getInstance();
cal1.setTime(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date2);
boolean isSameYear = cal1.get(Calendar.ERA) == cal2.get(Calendar.ERA) &&
cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR);
return isSameYear;
}
/**
* 判断是否是同一月
*
* @param date1
* @param date2
* @return
*/
public static boolean isSameMonth(Date date1, Date date2) {
if (date1 == null || date2 == null) {
throw new IllegalArgumentException("The date must not be null");
}
Calendar cal1 = Calendar.getInstance();
cal1.setTime(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date2);
boolean isSameMonth = cal1.get(Calendar.ERA) == cal2.get(Calendar.ERA) &&
cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)
&& cal1.get(Calendar.MONTH) == cal2.get(Calendar.MONTH);
return isSameMonth;
}
/**
* 判断是否是同一天
*
* @param date1
* @param date2
* @return
*/
public static boolean isSameDay(Date date1, Date date2) {
if (date1 == null || date2 == null) {
throw new IllegalArgumentException("The date must not be null");
}
Calendar cal1 = Calendar.getInstance();
cal1.setTime(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date2);
boolean isSameDay = cal1.get(Calendar.ERA) == cal2.get(Calendar.ERA) &&
cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)
&& cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR);
return isSameDay;
}
/**
* 获取当前时间+1天（第二天凌晨）
*
* @param str num 天数
* @return
* @Author wugucheng
*/
public static Date addMidDay(Date str, int num) {
Calendar rightNow = Calendar.getInstance();
Date formatStr = new Date();
try {
rightNow.setTime(str);
rightNow.add(Calendar.DATE, num);
formatStr = rightNow.getTime();
} catch (Exception e) {
log.info("s!", e);
}
return formatStr;
}
/**
* 获取当前时间加小时
*
* @param str num 小时
* @return
* @Author wugucheng
*/
public static Date addHour(Date str, int num) {
Calendar rightNow = Calendar.getInstance();
Date formatStr = new Date();
try {
rightNow.setTime(str);
rightNow.add(Calendar.HOUR, num);
formatStr = rightNow.getTime();
} catch (Exception e) {
log.info("s!", e);
}
return formatStr;
}
/**
* 获取时间文本
*
* @param hour
* @param minute
* @return
*/
public static String getTimeString(Integer hour, Integer minute) {
if (hour == null && minute == null) {
return null;
}
if (hour == null) {
return minute + "分钟";
}
if (minute == null) {
return hour + "小时";
}
return hour + "小时" + minute + "分钟";
}
/**
* 获取下 num 月时间
*
* @param date
* @param num
* @return
*/
public static Date addMidMonth(Date date, int num) {
Calendar calendar = Calendar.getInstance();
Date formatStr = new Date();
try {
calendar.setTime(date);
calendar.add(Calendar.MONTH, num);
formatStr = calendar.getTime();
} catch (Exception e) {
log.info("s!", e);
}
return formatStr;
}
/**
* 日期转星期几
*
* @param date
* @return -1表示无效
*/
public static int dateToWeek(Date date) {
if (date == null) {
return -1;
}
int[] weekDays = {7, 1, 2, 3, 4, 5, 6};
Calendar cal = Calendar.getInstance(); // 获得一个日历
cal.setTime(date);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1; // 指示一个星期中的某天。
if (w < 0) {
return -1;
}
return weekDays[w];
}
/**
* 返回date的时分
*
* @param date
* @return
*/
public static String getDateHourAndMinus(Date date) {
if (date == null) {
return null;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");
return simpleDateFormat.format(date);
}
/**
* 返回date的年月日
*
* @param date
* @return
*/
public static String getDateYearAndMonthAndDay(Date date) {
if (date == null) {
return null;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
return simpleDateFormat.format(date);
}
/**
* 获取单独的日并将date->int
*
* @param date
* @return
*/
public static int getDayCount(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(date.getTime());
int day = cal.get(Calendar.DATE);
return day;
}
/**
* 获取当月总天数
*
* @param date
* @return
*/
public static int getDaysOfMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 获取当年总天数
*
* @param date
* @return
*/
public static int getDaysOfYear(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
}
/**
* 获取当前时间-n月
*
* @param str num 月数
* @return
*/
public static Date reduceMonth(Date str, int num) {
Calendar rightNow = Calendar.getInstance();
Date formatStr = new Date();
try {
rightNow.setTime(str);
rightNow.add(Calendar.MONTH, -num);
formatStr = rightNow.getTime();
} catch (Exception e) {
log.info("s!", e);
}
return formatStr;
}
/**
* 获取两个日期之间的所有日期 (不包含结束日期)
*
* @param startDate
* @param endDate
* @return
*/
public static List<Date> getBetweenDates(Date startDate, Date endDate) {
List<Date> result = new ArrayList<>();
Calendar tempStart = Calendar.getInstance();
tempStart.setTime(startDate);
Calendar tempEnd = Calendar.getInstance();
tempEnd.setTime(endDate);
while (tempStart.before(tempEnd)) {
result.add(tempStart.getTime());
tempStart.add(Calendar.DAY_OF_YEAR, 1);
}
return result;
}
/**
* 获取两个日期之间的日期字符串
*
* @param startDate
* @param endDate
* @param dateFormatStr
* @return
*/
public static List<String> getBetweenDatesStr(String startDate, String endDate, String dateFormatStr) {
List<String> days = new ArrayList<>();
DateFormat dateFormat = new SimpleDateFormat(dateFormatStr);
try {
Date start = dateFormat.parse(startDate);
Date end = dateFormat.parse(endDate);
Calendar tempStart = Calendar.getInstance();
tempStart.setTime(start);
Calendar tempEnd = Calendar.getInstance();
tempEnd.setTime(end);
tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
while (tempStart.before(tempEnd)) {
days.add(dateFormat.format(tempStart.getTime()));
tempStart.add(Calendar.DAY_OF_YEAR, 1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return days;
}
/**
* yyyy-mm格式获取相差num月格式
*
* @param month
* @param num
* @return
*/
public static String getMonthAddNum(String month, int num) {
Date date = DateUtil.stringToDate(month, DateUtil.DATE_MONTH_FORMATER);
return DateUtil.dateToString(DateUtil.addMidMonth(date, num), DateUtil.DATE_MONTH_FORMATER);
}
/**
* 获取当前时间当年最后一天
*
* @param date
* @return Date
*/
public static Date getLastDayOfYear(final Date date) {
final Calendar cal = Calendar.getInstance();
cal.setTime(date);
final int last = cal.getActualMaximum(Calendar.DAY_OF_YEAR);
cal.set(Calendar.DAY_OF_YEAR, last);
return cal.getTime();
}
/**
* 获取传入时间是哪月
*
* @param date 日期
* @return
*/
public static int getDateOfMonth(Date date) {
if (date == null) {
return 0;
}
Calendar c1 = Calendar.getInstance();
c1.setTime(date);
return c1.get(Calendar.MONTH) + 1;
}
/**
* 事件+分钟数
*
* @param date 日期
* @return
*/
public static Date addMinuteToDate(Date date, int num) {
SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.DATE_HOUR_FORMATTER);
Calendar c1 = Calendar.getInstance();
c1.setTime(date);
c1.add(Calendar.MINUTE, num);
return stringToDate(sdf.format(c1.getTime()), DateUtil.DATE_HOUR_FORMATTER);
}
/**
* 返回指定月份的最后一天的59分59秒
*/
public static Date getLastMonthOfDate(Date date) {
Calendar para = Calendar.getInstance(java.util.Locale.CHINA);
para.setTime(date);
para.set(Calendar.DATE, para.getActualMaximum(Calendar.DAY_OF_MONTH));
para.set(Calendar.HOUR_OF_DAY, 23);
para.set(Calendar.MINUTE, 59);
para.set(Calendar.SECOND, 59);
return para.getTime();
}
/**
* 获取本周的开始时间
*
* @return
*/
public static Date getBeginTimeOfWeek() {
Calendar cal = Calendar.getInstance();
cal.setFirstDayOfWeek(Calendar.MONDAY);
cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
return cal.getTime();
}
/**
* 获取上月第一天
*/
public static Date getLastMonthFirstDay() {
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MONTH, -1);
cal.set(Calendar.DAY_OF_MONTH, 1);
return DateUtil.stringToDate(myFormatter.format(cal.getTime()) + " 00:00:00", DateUtil.DATETIME_FORMATTER);
}
/**
* 获取上月最后一天
*/
public static Date getLastMonthEndDay() {
Calendar calendar = Calendar.getInstance();
int month = calendar.get(Calendar.MONTH);
calendar.set(Calendar.MONTH, month - 1);
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
return calendar.getTime();
}
/**
* 是分割日期格式
*
* @param date
* @return
*/
public static boolean isDivDate(String date) {
if (StringUtils.isBlank(date)) {
return false;
}
Pattern pattern = Pattern.compile("^[0-9]{4}-(((0[13578]|(10|12))-(0[1-9]|[1-2][0-9]|3[0-1]))|(02-(0[1-9]|[1-2][0-9]))|((0[469]|11)-(0[1-9]|[1-2][0-9]|30)))$");
boolean matches = pattern.matcher(date).matches();
if (!matches) {
return false;
}
return true;
}
/**
* 是无分割日期格式
*
* @param date
* @return
*/
public static boolean isNoDivDate(String date) {
if (StringUtils.isBlank(date)) {
return false;
}
Pattern pattern = Pattern.compile("^([0-9]\\d{3}((0[1-9]|1[012])(0[1-9]|1\\d|2[0-8])|(0[13456789]|1[012])(29|30)|(0[13578]|1[02])31)|(([2-9]\\d)(0[48]|[2468][048]|[13579][26])|(([2468][048]|[3579][26])00))0229)$");
boolean matches = pattern.matcher(date).matches();
if (!matches) {
return false;
}
return true;
}
/**
* 是日期格式字符串
*
* @param date
* @return
*/
public static boolean isDateStr(String date) {
if (StringUtils.isBlank(date)) {
return false;
}
return isDivDate(date) || isNoDivDate(date);
}
/**
* 两个时间相差是否大于两小时
*
* @param startDate
* @param endDate
* @return
*/
public static boolean subTimeThanTwoHours(Date startDate, Date endDate) {
return endDate.getTime() - startDate.getTime() >= TWO_HOURS;
}
/**
* 两个时间相差是否大于一天
*
* @param startDate
* @param endDate
* @return
*/
public static boolean subTimeThanOneDay(Date startDate, Date endDate) {
return endDate.getTime() - startDate.getTime() >= ONE_DAY;
}
/**
* 当前时间是否在两个时间段之内（跨日期，小时）
*
* @param startTime
* @param endTime
* @return
*/
public static boolean isBetweenTime(LocalTime startTime, LocalTime endTime, LocalTime betweenTime) {
return betweenTime.isAfter(startTime) || betweenTime.isBefore(endTime);
}
/**
* date转 LocalTime
*
* @param date
* @return
*/
public static LocalTime dateToLocalTime(Date date) {
Instant instant = date.toInstant();
ZoneId zone = ZoneId.systemDefault();
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
return localDateTime.toLocalTime();
}
/**
* 转有分割日期
*
* @param dateStr
* @return
*/
public static String toDivDateStr(String dateStr) {
if (StringUtils.isBlank(dateStr)) {
return null;
}
if (isDivDate(dateStr)) {
return dateStr;
}
if (isNoDivDate(dateStr)) {
return StringUtils.substring(dateStr, 0, 4) + "-" + StringUtils.substring(dateStr, 4, 6) + "-" + StringUtils.substring(dateStr, 6, 8);
}
return null;
}
/**
* 获取传入日期所在月的第一天
*
* @param date
* @return
*/
public static Date getFirstDayDateOfMonth(final Date date) {
final Calendar cal = Calendar.getInstance();
cal.setTime(date);
final int last = cal.getActualMinimum(Calendar.DAY_OF_MONTH);
cal.set(Calendar.DAY_OF_MONTH, last);
return cal.getTime();
}
/**
* 获取传入日期所在月的最后一天
*
* @param date
* @return
*/
public static Date getLastDayOfMonth(final Date date) {
final Calendar cal = Calendar.getInstance();
cal.setTime(date);
final int last = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
cal.set(Calendar.DAY_OF_MONTH, last);
return cal.getTime();
}
/**
* 根据时间往前往后推N分钟
* @param time
* @param number
* @return
*/
public static Date adjustTimeFromNumber(Date time, Integer number){
Calendar calendar = Calendar.getInstance();
calendar.setTime(time);
calendar.add(Calendar.MINUTE, number);
return calendar.getTime();
}
/**
* 获取精确到秒的时间戳
* @param date
*/
public static String getSecondTimestamp(Date date) {
if (null == date) {
return "0";
}
return String.valueOf(date.getTime() / 1000);
}
/**
* 计算两个时间相差的天 时 分
* @param endDate
* @param nowDate
* @return
*/
public static String getDiffDayHourMinute(Date endDate, Date nowDate) {
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = Math.abs(diff / nd);
// 计算差多少小时
long hour = Math.abs(diff % nd / nh);
// 计算差多少分钟
long min = Math.abs(diff % nd % nh / nm);
return day + "天" + hour + "小时" + min + "分钟";
}
/**
* 计算两个时间相差的天 时 分
* @param endDate
* @param nowDate
* @return 返回Map
*/
public static Map<String,Long> getDiffDayHourMinuteMap(Date endDate, Date nowDate) {
Map<String,Long> dhmMap = new HashMap();
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = Math.abs(diff / nd);
// 计算差多少小时
long hour = Math.abs(diff % nd / nh);
// 计算差多少分钟
long min = Math.abs(diff % nd % nh / nm);
dhmMap.put("day",day);
dhmMap.put("hour",hour);
dhmMap.put("min",min);
return dhmMap;
}
/**
* 获取今天星期几
* @param nowDate 今日的日期
* @return
*/
public static String getDayOfTheWeek(Date nowDate){
String[] weeks = {"周日","周一","周二","周三","周四","周五","周六"};
Calendar cal = Calendar.getInstance();
cal.setTime(nowDate);
int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
if(week_index<0){
week_index = 0;
}
return weeks[week_index];
}
/**
* endTime 在当前时间之前
* @param nowTime
* @param endTime
* @return
*/
public static Boolean isBeforeNowTime(Date nowTime,Date endTime){
if(ObjectUtils.isEmpty(nowTime) || ObjectUtils.isEmpty(endTime)){
return null;
}
if(nowTime.getTime() > endTime.getTime()){
return true;
}else if(nowTime.getTime() < endTime.getTime()){
return false;
}
return null;
}
/**
* long转date
* @param dateLong 毫秒
* @return
*/
public Date longToDate(long dateLong){
Date date = new Date(dateLong);
return date;
}
/**
* date转long
* @param date
* @return
*/
public long dateToLong(Date date){
long dateLong = date.getTime();
return dateLong;
}
/**
* 获取当前日期的前一天
* @return
*/
public static String getCurrentDateBeforeDay(){
Calendar cal =Calendar.getInstance();
cal.add(Calendar.DATE, -1);
String yesterday = new SimpleDateFormat( "yyyy-MM-dd ").format(cal.getTime());
return yesterday;
}
/**
* 将秒转换为 天，小时，分钟
* @param second
* @return
*/
public static String secondToDayHourMin(Long second){
long days = second / (60 * 60 * 24);
long hours = (second % (60 * 60 * 24)) / (60 * 60);
long minutes = (second % (60 * 60)) / (60);
long seconds = second % 60;
if(seconds >= 30){
minutes++;
}
return days + "," + hours + "," + minutes;
}
/**
* 字符串日期转小时
* @param date 字符串日期
* @param format 日期格式
* @return
*/
public static Integer stringDateToHour(String date,String format){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
SimpleDateFormat sdf = new SimpleDateFormat("HH");
String hhToString = null;
try {
hhToString = sdf.format( simpleDateFormat.parse(date));
} catch (ParseException e) {
e.printStackTrace();
}
Integer hhToInt = Integer.valueOf(hhToString);
return hhToInt;
}
/**
* 获取一年的开始时间
* @param date
* @return
*/
public static Date getBeginDayOfYear(String date) {
LocalDate today;
if (null==date){
today = LocalDate.now();
}else {
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
today=LocalDate.parse(date, fmt);
}
today = LocalDate.of(today.getYear(), Month.JANUARY, 1);
LocalDateTime localDateTime = today.atTime(00, 00, 01);
ZoneId zoneId = ZoneId.systemDefault();
ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
Date dateTime = Date.from(zonedDateTime.toInstant());
return dateTime;
}
/**
* 获取一年的结束时间
* @param date
* @return
*/
public static Date getEndDayOfYear(String date) {
LocalDate today;
if (null==date){
today = LocalDate.now();
}else {
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
today=LocalDate.parse(date, fmt);
}
today = LocalDate.of(today.getYear(), Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
LocalDateTime localDateTime = today.atTime(23, 59, 59);
ZoneId zoneId = ZoneId.systemDefault();
ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
Date dateTime = Date.from(zonedDateTime.toInstant());
return dateTime;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
- 413
- 414
- 415
- 416
- 417
- 418
- 419
- 420
- 421
- 422
- 423
- 424
- 425
- 426
- 427
- 428
- 429
- 430
- 431
- 432
- 433
- 434
- 435
- 436
- 437
- 438
- 439
- 440
- 441
- 442
- 443
- 444
- 445
- 446
- 447
- 448
- 449
- 450
- 451
- 452
- 453
- 454
- 455
- 456
- 457
- 458
- 459
- 460
- 461
- 462
- 463
- 464
- 465
- 466
- 467
- 468
- 469
- 470
- 471
- 472
- 473
- 474
- 475
- 476
- 477
- 478
- 479
- 480
- 481
- 482
- 483
- 484
- 485
- 486
- 487
- 488
- 489
- 490
- 491
- 492
- 493
- 494
- 495
- 496
- 497
- 498
- 499
- 500
- 501
- 502
- 503
- 504
- 505
- 506
- 507
- 508
- 509
- 510
- 511
- 512
- 513
- 514
- 515
- 516
- 517
- 518
- 519
- 520
- 521
- 522
- 523
- 524
- 525
- 526
- 527
- 528
- 529
- 530
- 531
- 532
- 533
- 534
- 535
- 536
- 537
- 538
- 539
- 540
- 541
- 542
- 543
- 544
- 545
- 546
- 547
- 548
- 549
- 550
- 551
- 552
- 553
- 554
- 555
- 556
- 557
- 558
- 559
- 560
- 561
- 562
- 563
- 564
- 565
- 566
- 567
- 568
- 569
- 570
- 571
- 572
- 573
- 574
- 575
- 576
- 577
- 578
- 579
- 580
- 581
- 582
- 583
- 584
- 585
- 586
- 587
- 588
- 589
- 590
- 591
- 592
- 593
- 594
- 595
- 596
- 597
- 598
- 599
- 600
- 601
- 602
- 603
- 604
- 605
- 606
- 607
- 608
- 609
- 610
- 611
- 612
- 613
- 614
- 615
- 616
- 617
- 618
- 619
- 620
- 621
- 622
- 623
- 624
- 625
- 626
- 627
- 628
- 629
- 630
- 631
- 632
- 633
- 634
- 635
- 636
- 637
- 638
- 639
- 640
- 641
- 642
- 643
- 644
- 645
- 646
- 647
- 648
- 649
- 650
- 651
- 652
- 653
- 654
- 655
- 656
- 657
- 658
- 659
- 660
- 661
- 662
- 663
- 664
- 665
- 666
- 667
- 668
- 669
- 670
- 671
- 672
- 673
- 674
- 675
- 676
- 677
- 678
- 679
- 680
- 681
- 682
- 683
- 684
- 685
- 686
- 687
- 688
- 689
- 690
- 691
- 692
- 693
- 694
- 695
- 696
- 697
- 698
- 699
- 700
- 701
- 702
- 703
- 704
- 705
- 706
- 707
- 708
- 709
- 710
- 711
- 712
- 713
- 714
- 715
- 716
- 717
- 718
- 719
- 720
- 721
- 722
- 723
- 724
- 725
- 726
- 727
- 728
- 729
- 730
- 731
- 732
- 733
- 734
- 735
- 736
- 737
- 738
- 739
- 740
- 741
- 742
- 743
- 744
- 745
- 746
- 747
- 748
- 749
- 750
- 751
- 752
- 753
- 754
- 755
- 756
- 757
- 758
- 759
- 760
- 761
- 762
- 763
- 764
- 765
- 766
- 767
- 768
- 769
- 770
- 771
- 772
- 773
- 774
- 775
- 776
- 777
- 778
- 779
- 780
- 781
- 782
- 783
- 784
- 785
- 786
- 787
- 788
- 789
- 790
- 791
- 792
- 793
- 794
- 795
- 796
- 797
- 798
- 799
- 800
- 801
- 802
- 803
- 804
- 805
- 806
- 807
- 808
- 809
- 810
- 811
- 812
- 813
- 814
- 815
- 816
- 817
- 818
- 819
- 820
- 821
- 822
- 823
- 824
- 825
- 826
- 827
- 828
- 829
- 830
- 831
- 832
- 833
- 834
- 835
- 836
- 837
- 838
- 839
- 840
- 841
- 842
- 843
- 844
- 845
- 846
- 847
- 848
- 849
- 850
- 851
- 852
- 853
- 854
- 855
- 856
- 857
- 858
- 859
- 860
- 861
- 862
- 863
- 864
- 865
- 866
- 867
- 868
- 869
- 870
- 871
- 872
- 873
- 874
- 875
- 876
- 877
- 878
- 879
- 880
- 881
- 882
- 883
- 884
- 885
- 886
- 887
- 888
- 889
- 890
- 891
- 892
- 893
- 894
- 895
- 896
- 897
- 898
- 899
- 900
- 901
- 902
- 903
- 904
- 905
- 906
- 907
- 908
- 909
- 910
- 911
- 912
- 913
- 914
- 915
- 916
- 917
- 918
- 919
- 920
- 921
- 922
- 923
- 924
- 925
- 926
- 927
- 928
- 929
- 930
- 931
- 932
- 933
- 934
- 935
- 936
- 937
- 938
- 939
- 940
- 941
- 942
- 943
- 944
- 945
- 946
- 947
- 948
- 949
- 950
- 951
- 952
- 953
- 954
- 955
- 956
- 957
- 958
- 959
- 960
- 961
- 962
- 963
- 964
- 965
- 966
- 967
- 968
- 969
- 970
- 971
- 972
- 973
- 974
- 975
- 976
- 977
- 978
- 979
- 980
- 981
- 982
- 983
- 984
- 985
- 986
- 987
- 988
- 989
- 990
- 991
- 992
- 993
- 994
- 995
- 996
- 997
- 998
- 999
- 1000
- 1001
- 1002
- 1003
- 1004
- 1005
- 1006
- 1007
- 1008
- 1009
- 1010
- 1011
- 1012
- 1013
- 1014
- 1015
- 1016
- 1017
- 1018
- 1019
- 1020
- 1021
- 1022
- 1023
- 1024
- 1025
- 1026
- 1027
- 1028
- 1029
- 1030
- 1031
- 1032
- 1033
- 1034
- 1035
- 1036
- 1037
- 1038
- 1039
- 1040
- 1041
- 1042
- 1043
- 1044
- 1045
- 1046
- 1047
- 1048
- 1049
- 1050
- 1051
- 1052
- 1053
- 1054
- 1055
- 1056
- 1057
- 1058
- 1059
- 1060
- 1061
- 1062
- 1063
- 1064
- 1065
- 1066
- 1067
- 1068
- 1069
- 1070
- 1071
- 1072
- 1073
- 1074
- 1075
- 1076
- 1077
- 1078
- 1079
- 1080
- 1081
- 1082
- 1083
- 1084
- 1085
- 1086
- 1087
- 1088
- 1089
- 1090
- 1091
- 1092
- 1093
- 1094
- 1095
- 1096
- 1097
- 1098
- 1099
- 1100
- 1101
- 1102
- 1103
- 1104
- 1105
- 1106
- 1107
- 1108
- 1109
- 1110
- 1111
- 1112
- 1113
- 1114
- 1115
- 1116
- 1117
- 1118
- 1119
- 1120
- 1121
- 1122
- 1123
- 1124
- 1125
- 1126
- 1127
- 1128
- 1129
- 1130
- 1131
- 1132
- 1133
- 1134
- 1135
- 1136
- 1137
- 1138
- 1139
- 1140
- 1141
- 1142
- 1143
- 1144
- 1145
- 1146
- 1147
- 1148
- 1149
- 1150
- 1151
- 1152
- 1153
- 1154
- 1155
- 1156
- 1157
- 1158
- 1159
- 1160
- 1161
- 1162
- 1163
- 1164
- 1165
- 1166
- 1167
- 1168
- 1169
- 1170
- 1171
- 1172
- 1173
- 1174
- 1175
- 1176
- 1177
- 1178
- 1179
- 1180
- 1181
- 1182
- 1183
- 1184
- 1185
- 1186
- 1187
- 1188
- 1189
- 1190
- 1191
- 1192
- 1193
- 1194
- 1195
- 1196
- 1197
- 1198
- 1199
- 1200
- 1201
- 1202
- 1203
- 1204
- 1205
- 1206
- 1207
- 1208
- 1209
- 1210
- 1211
- 1212
- 1213
- 1214
- 1215
- 1216
- 1217
- 1218
- 1219
- 1220
- 1221
- 1222
- 1223
- 1224
- 1225
- 1226
- 1227
- 1228
- 1229
- 1230
- 1231
- 1232
- 1233
- 1234
- 1235
- 1236
- 1237
- 1238
- 1239
- 1240
- 1241
- 1242
- 1243
- 1244
- 1245
- 1246
- 1247
- 1248
- 1249
- 1250
- 1251
- 1252
- 1253
- 1254
- 1255
- 1256
- 1257
- 1258
- 1259
- 1260
- 1261
- 1262
- 1263
- 1264
- 1265
- 1266
- 1267
- 1268
- 1269
- 1270
- 1271
- 1272
- 1273
- 1274
- 1275
- 1276
- 1277
- 1278
- 1279
- 1280
- 1281
- 1282
- 1283
- 1284
- 1285
- 1286
- 1287
- 1288
- 1289
- 1290
- 1291
- 1292
- 1293
- 1294
- 1295
- 1296
- 1297
- 1298
- 1299
- 1300
- 1301
- 1302
- 1303
- 1304
- 1305
- 1306
- 1307
- 1308
- 1309
- 1310
- 1311
- 1312
- 1313
- 1314
- 1315
- 1316
- 1317
- 1318
- 1319
- 1320
- 1321
- 1322
- 1323
- 1324
- 1325
- 1326
- 1327
- 1328
- 1329
- 1330
- 1331
- 1332
- 1333
- 1334
- 1335
- 1336
- 1337
- 1338
- 1339
- 1340
- 1341
- 1342
- 1343
- 1344
- 1345
- 1346
- 1347
- 1348
- 1349
- 1350
- 1351
- 1352
- 1353
- 1354
- 1355
- 1356
HttpClientUtil类：
package com.hjd.task.common.utils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.commons.lang3.StringUtils;
import org.jsoup.Connection;
import org.jsoup.Jsoup;
import java.io.IOException;
import java.util.Map;
@Slf4j
public class HttpClientUtil {
private static final HttpClient httpClient = new HttpClient();
static {
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
}
/**
* JSoup Post请求
* @param url 地址
* @param params JSON参数
* @return JSON字符串返回值
*/
public static String doPostJSoup(String url, String params) {
Connection.Response response = null;
try {
response = Jsoup.connect(url)
.header("content-type", "application/json;charset=utf-8")
.method(Connection.Method.POST)
.requestBody(params)
.ignoreContentType(true)
.execute();
return response.body();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* JSoup Post请求 带有 token
* @param url 地址
* @param tokenName token名称
* @param token token值
* @param params 参数
* @return JSON字符串返回值
*/
public static String doPostJSoup(String url,String tokenName,String token,String params){
Connection.Response response = null;
try {
Connection connect = Jsoup.connect(url);
connect.method(Connection.Method.POST);
if(StringUtils.isNotEmpty(tokenName) && StringUtils.isNotEmpty(token)){
connect.header(tokenName,token);
}
response = connect.ignoreContentType(true)
.execute();
return response.body();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* JSoup Get请求
* @param url 地址
* @param params 参数 类型Map
* @return JSON字符串返回值
*/
public static String doGetJSoup(String url, Map<String,String> params){
Connection.Response response = null;
try {
Connection connect = Jsoup.connect(url);
connect.method(Connection.Method.GET);
for(Map.Entry<String,String> entry : params.entrySet()){
connect.data(entry.getKey(),entry.getValue());
}
response = connect.ignoreContentType(true)
.execute();
return response.body();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 发送POST请求
*
* @param url
* @param paramJson
* @return
*/
public static String doPost(String url, String paramJson) {
log.info("开始发送POST请求;url:{};参数:", url, paramJson);
PostMethod postMethod = new PostMethod(url);
// 设置post请求超时时间
postMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
postMethod.addRequestHeader("Content-Type", "application/json");
String response = null;
try {
RequestEntity entity = new StringRequestEntity(paramJson, "application/json", "UTF-8");
postMethod.setRequestEntity(entity);
httpClient.executeMethod(postMethod);
response = postMethod.getResponseBodyAsString();
postMethod.releaseConnection();
} catch (IOException e) {
log.info("POST发出请求异常,异常原因:{}", e);
e.printStackTrace();
}
log.info("发送POST请求结束,返回值为:{}", response);
return response;
}
/**
* 发送GET请求
*
* @param urlParam
* @return
*/
public static String doGet(String urlParam) {
log.info("开始发送GET请求;url:{};", urlParam);
GetMethod getMethod = new GetMethod(urlParam);
getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
getMethod.addRequestHeader("Content-Type", "application/json");
String response = null;
try {
httpClient.executeMethod(getMethod);
response = getMethod.getResponseBodyAsString();
} catch (IOException e) {
log.info("GET发出请求异常,异常原因:{}", e);
e.printStackTrace();
}
log.info("发送GET请求结束,返回值为:{}", response);
return response;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
（2）发送消息效果：
3.2.1 步骤分解：
（1）调用获取token接口：
接口：
GET： https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APP_ID&secret=APP_SECRET
请求参数：
| appid | secret |
|---|---|
| 小程序id | 小程序密钥 |
参数说明：
appid和secret两个的值，可以在微信小程序后台找到。
返回值：
| access_token | expires_in |
|---|---|
| token值 | 有效时间 |
（2）调用发送消息接口：
接口：
POST: https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=TOKEN
请求参数：
| accessToken | touser | template_id | page | data |
|---|---|---|---|---|
token | 消息接收人 | 消息模板id | 点击消息详情跳转页面 | 消息内容 |
参数说明：
token: 通过步骤1获取
toUser：是微信用户的openId，在微信小程序登陆获取用户信息时可以拿到。
page：是点击消息进入小程序查看后跳转的页面。
data：是消息模板中的内容。需要注意消息模板中的内容都是以key和value的形式进行赋值并且展示的，拿下面的一个工作通知模板做例子：
我们可以看到该消息模板中的消息内容只有两个：温馨提示和时间，分别对应的key是thing6和time2。
切记，key一定要保持和模板中的一致！！！
3.3 可能遇到的问题
3.3.1 参数不合法：
错误内容：
{"errcode":47003,"errmsg":"argument invalid! data.thing6.value invalid rid: 63904a7c-774dbdca-33bce62d"}
- 1
原因：
（1）消息模板中的值为空。凡是在消息模板中展示的字段都是必填的。
（2）代码中的key和目标中的不对应。
（3）key对应的value内容过长。
4.实际应用
通过上述介绍，我想大家对微信小程序发送模板消息有两个大概的认识。
我们知道用户同意订阅消息后，服务器端只能发一条消息给用户，后面如果想再次发送，还需要去询问用户是否订阅。那么如果我们想持续的给用户发消息呢？我们该如何应对这样的场景呢？
4.1 “总是保持以上选择”
在询问用户是否同意接收消息时，下方有个总是保持以上选择，如果用户勾选了，并点击确定，那么后面如果再次询问用户是否同意接收消息时，就不会弹出订阅消息界面。
我们该如何判断用户勾选了保持以上选择呢?
可以通过微信小程序的wx.getSetting({})方法。这个方法会在勾选了保持以上选择后，会打印出模板id。所以我们需要在订阅界面成功回调方法中，判断下setting中是否包含模板id。
4.2 实现思路
- 在后台数据库中给微信用户添加一个
字段:check_flag表示，表示是否勾选总是保持以上选择，true:勾选了，false:未勾选。 - 在
wx.requestSubscribeMessage()成功回调方法中调用wx.setting()中判断用户是否勾选了总是保持以上选择。 - 如果是，修改
check_flag=true。 - 在
微信小程序中必点击的地方，添加调用wx.requestSubscribeMessage()方法。 - 如果
check_flag为true时调用wx.requestSubscribeMessage()。
然后就可以实现用户在登陆界面点击一次发送多条消息给用户。如果用户不想再次接收消息。可以在我小程序右上角三个点设置中修改即可。
4.3 代码：
//在用户必点的地方，调用订阅消息方法
clickSubscribeMessage(){
let flag = wx.getStorageSync('checkFlag');
console.log(false);
//订阅消息
if(flag == 1){
let workTaskTemplateId = app.globalData.workTaskTemplateId;
wx.requestSubscribeMessage({
tmplIds: [workTaskTemplateId],
success(res){
console.log(res);
},
fail(res){
console.log(res);
}
})
}
}
...
//订阅消息
subScriptionMessage(){
var that = this;
//模板id
let workTaskTemplateId = 'xxx';
wx.requestSubscribeMessage({
tmplIds: [workTaskTemplateId],
success (res) {
if(JSON.stringify(res).indexOf("reject") != -1){
console.log("拒绝")
}
if(JSON.stringify(res).indexOf("accept") != -1){
console.log("接受")
wx.getSetting({
withSubscriptions: true,
success (res) {
console.log(res.subscriptionsSetting)
if(JSON.stringify(res.subscriptionsSetting).indexOf(workTaskTemplateId) != -1){
console.log("用户选择了“保持以上选择”")
that.checkFlag();
}
}
})
}
},
fail(res){
console.log(res);
}
})
},
...
//请求后台接口，修改check_flag
checkFlag(){
//请求后台修改check_flag 字段为true
wx.request({
url: 'xxxx',
...
success:function(res){
//如果修改成功将check_status字段放到storage中
wx.setStorageSync("checkFlag",true)
},
fail:function(res){},
})
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
如果大家有更好的方法请留言。上面截图例子来自于我做的一个微信小程序TaskPlan。链接如下，欢迎来参观：
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/113094
推荐阅读
相关标签
