admin/sms4j
1
0
Fork 0
mirror of https://gitee.com/dromara/sms4j.git synced 2025-12-06 17:08:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev-2.x-experimental' into dev-2.x

Browse Source 
# Conflicts:
#	sms4j-provider/src/main/java/org/dromara/sms4j/emay/service/EmaySmsImpl.java
This commit is contained in:
wind 2023-05-17 18:22:52 +08:00
commit ab81bd3360
12 changed files with 240 additions and 871 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
sms4j-api/src/main/java/org/dromara/sms4j/api/AbstractSmsBlend.java Normal file
View File

@ -0,0 +1,206 @@
package org.dromara.sms4j.api;
import com.dtflys.forest.config.ForestConfiguration;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.factory.BeanFactory;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.TimerTask;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
public abstract class AbstractSmsBlend implements SmsBlend{
protected final Executor pool;
protected final DelayedTime delayed;
protected final ForestConfiguration http = BeanFactory.getForestConfiguration();
protected AbstractSmsBlend(Executor pool, DelayedTime delayed) {
this.pool = pool;
this.delayed = delayed;
}
/**
* <p>说明：发送固定消息模板短信
* <p>此方法将使用配置文件中预设的短信模板进行短信发送
* <p>该方法指定的模板变量只能存在一个（配置文件中）
* <p>如使用的是腾讯的短信，参数字符串中可以同时存在多个参数，使用 & 分隔例如：您的验证码为{1}在{2}分钟内有效，可以传为 message="xxxx"+"&"+"5"
* sendMessage
*
* @param phone 接收短信的手机号
* message 消息内容
* @author :Wind
*/
public abstract SmsResponse sendMessage(String phone, String message);
/**
* <p>说明：使用自定义模板发送短信
* sendMessage
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @author :Wind
*/
public abstract SmsResponse sendMessage(String phone, String templateId, LinkedHashMap<String, String> messages);
/**
* <p>说明：群发固定模板短信
* massTexting
*
* @author :Wind
*/
public abstract SmsResponse massTexting(List<String> phones, String message);
/**
* <p>说明：使用自定义模板群发短信
* massTexting
*
* @author :Wind
*/
public abstract SmsResponse massTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages);
/**
* <p>说明：异步短信发送，固定消息模板短信
* sendMessageAsync
*
* @param phone 要发送的号码
* @param message 发送内容
* @param callBack 回调
* @author :Wind
*/
@Restricted
public final void sendMessageAsync(String phone, String message, CallBack callBack){
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
/**
* <p>说明：异步发送短信，不关注发送结果
* sendMessageAsync
*
* @param phone 要发送的号码
* @param message 发送内容
* @author :Wind
*/
@Restricted
public final void sendMessageAsync(String phone, String message){
pool.execute(() -> {
sendMessage(phone, message);
});
}
/**
* <p>说明：异步短信发送，使用自定义模板发送短信
* sendMessage
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @param callBack 回调
* @author :Wind
*/
@Restricted
public final void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack){
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone,templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
/**
* <p>说明：异步短信发送，使用自定义模板发送短信，不关注发送结果
* sendMessageAsync
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @author :Wind
*/
@Restricted
public final void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages){
pool.execute(() -> {
sendMessage(phone, templateId, messages);
});
}
/**
* <p>说明：使用固定模板发送延时短信
* delayedMessage
*
* @param phone 接收短信的手机号
* @param message 要发送的短信
* @param delayedTime 延迟时间
* @author :Wind
*/
@Restricted
public final void delayedMessage(String phone, String message, Long delayedTime){
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
/**
* <p>说明：使用自定义模板发送定时短信 sendMessage
* delayedMessage
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @param phone 要发送的手机号
* @param delayedTime 延迟的时间
* @author :Wind
*/
@Restricted
public final void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime){
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
/**
* <p>说明：群发延迟短信
* delayMassTexting
*
* @param phones 要群体发送的手机号码
* @author :Wind
*/
@Restricted
public final void delayMassTexting(List<String> phones, String message, Long delayedTime){
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
/**
* <p>说明：使用自定义模板发送群体延迟短信
* delayMassTexting
*
* @param phones 要群体发送的手机号码
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @param delayedTime 延迟的时间
* @author :Wind
*/
@Restricted
public final void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime){
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
}

113
sms4j-api/src/main/java/org/dromara/sms4j/api/SmsBlend.java
View File

@ -6,136 +6,35 @@ import org.dromara.sms4j.api.entity.SmsResponse;
import java.util.LinkedHashMap;
import java.util.List;
/**
* SmsBlend
* <p> 通用接口，定义国内短信方法
* @author :Wind
* 2023/5/16 16:03
**/
public interface SmsBlend {
/**
* <p>说明：发送固定消息模板短信
* <p>此方法将使用配置文件中预设的短信模板进行短信发送
* <p>该方法指定的模板变量只能存在一个（配置文件中）
* <p>如使用的是腾讯的短信，参数字符串中可以同时存在多个参数，使用 & 分隔例如：您的验证码为{1}在{2}分钟内有效，可以传为 message="xxxx"+"&"+"5"
* sendMessage
*
* @param phone 接收短信的手机号
* message 消息内容
* @author :Wind
*/
SmsResponse sendMessage(String phone, String message);
/**
* <p>说明：使用自定义模板发送短信
* sendMessage
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @author :Wind
*/
SmsResponse sendMessage(String phone, String templateId, LinkedHashMap<String, String> messages);
/**
* <p>说明：群发固定模板短信
* massTexting
*
* @author :Wind
*/
SmsResponse massTexting(List<String> phones, String message);
/**
* <p>说明：使用自定义模板群发短信
* massTexting
*
* @author :Wind
*/
SmsResponse massTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages);
/**
* <p>说明：异步短信发送，固定消息模板短信
* sendMessageAsync
*
* @param phone 要发送的号码
* @param message 发送内容
* @param callBack 回调
* @author :Wind
*/
void sendMessageAsync(String phone, String message, CallBack callBack);
/**
* <p>说明：异步发送短信，不关注发送结果
* sendMessageAsync
*
* @param phone 要发送的号码
* @param message 发送内容
* @author :Wind
*/
void sendMessageAsync(String phone, String message);
/**
* <p>说明：异步短信发送，使用自定义模板发送短信
* sendMessage
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @param callBack 回调
* @author :Wind
*/
void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack);
/**
* <p>说明：异步短信发送，使用自定义模板发送短信，不关注发送结果
* sendMessageAsync
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @author :Wind
*/
void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages);
/**
* <p>说明：使用固定模板发送延时短信
* delayedMessage
*
* @param phone 接收短信的手机号
* @param message 要发送的短信
* @param delayedTime 延迟时间
* @author :Wind
*/
void delayedMessage(String phone, String message, Long delayedTime);
/**
* <p>说明：使用自定义模板发送定时短信 sendMessage
* delayedMessage
*
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @param phone 要发送的手机号
* @param delayedTime 延迟的时间
* @author :Wind
*/
void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime);
/**
* <p>说明：群发延迟短信
* delayMassTexting
*
* @param phones 要群体发送的手机号码
* @author :Wind
*/
void delayMassTexting(List<String> phones, String message, Long delayedTime);
/**
* <p>说明：使用自定义模板发送群体延迟短信
* delayMassTexting
*
* @param phones 要群体发送的手机号码
* @param templateId 模板id
* @param messages key为模板变量名称 value为模板变量值
* @param delayedTime 延迟的时间
* @author :Wind
*/
void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime);
}

1
sms4j-core/src/main/java/org/dromara/sms4j/core/config/SupplierFactory.java
View File

@ -17,7 +17,6 @@ import org.dromara.sms4j.yunpian.config.YunpianConfig;
/**
* SupplierFactory
* <p> 差异化配置工厂
*
* @author :Wind
* 2023/4/8 15:02
**/

93
sms4j-provider/src/main/java/org/dromara/sms4j/aliyun/service/AlibabaSmsImpl.java
View File

@ -1,23 +1,18 @@
package org.dromara.sms4j.aliyun.service;
import com.alibaba.fastjson.JSON;
import com.dtflys.forest.config.ForestConfiguration;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.aliyun.config.AlibabaConfig;
import org.dromara.sms4j.aliyun.utils.AliyunUtils;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.exception.SmsBlendException;
import org.dromara.sms4j.comm.factory.BeanFactory;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
@ -29,25 +24,18 @@ import java.util.concurrent.atomic.AtomicReference;
**/
@Slf4j
public class AlibabaSmsImpl implements SmsBlend {
public class AlibabaSmsImpl extends AbstractSmsBlend {
private final AlibabaConfig alibabaSmsConfig;
private final Executor pool;
private final DelayedTime delayed;
private final ForestConfiguration http = BeanFactory.getForestConfiguration();
/**
* AlibabaSmsImpl
* <p>构造器，用于构造短信实现模块
* @author :Wind
*/
public AlibabaSmsImpl(AlibabaConfig alibabaSmsConfig, Executor pool, DelayedTime delayedTime) {
super(pool, delayedTime);
this.alibabaSmsConfig = alibabaSmsConfig;
this.pool = pool;
this.delayed = delayedTime;
}
@Override
@ -92,7 +80,7 @@ public class AlibabaSmsImpl implements SmsBlend {
throw new SmsBlendException(e.getMessage());
}
log.debug("requestUrl {}", requestUrl);
http.post(requestUrl)
super.http.post(requestUrl)
.addHeader("Content-Type", "application/x-www-form-urlencoded")
.addBody(paramStr)
.onSuccess(((data, req, res) -> {
@ -122,79 +110,6 @@ public class AlibabaSmsImpl implements SmsBlend {
return smsResponse;
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> {
sendMessage(phone, message);
});
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone,templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> {
sendMessage(phone, templateId, messages);
});
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
private String arrayToString(List<String> list) {
StringBuilder sb = new StringBuilder();

83
sms4j-provider/src/main/java/org/dromara/sms4j/cloopen/service/CloopenSmsImpl.java
View File

@ -4,8 +4,7 @@ import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.IdUtil;
import com.dtflys.forest.Forest;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.cloopen.api.CloopenRestApi;
import org.dromara.sms4j.cloopen.config.CloopenConfig;
@ -14,7 +13,6 @@ import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
/**
@ -24,20 +22,15 @@ import java.util.concurrent.Executor;
* @since 2023/4/10 22:10
*/
@Slf4j
public class CloopenSmsImpl implements SmsBlend {
public class CloopenSmsImpl extends AbstractSmsBlend {
private final CloopenRestApi restApi;
private final CloopenConfig config;
private final Executor pool;
private final DelayedTime delayed;
public CloopenSmsImpl(CloopenConfig config, Executor pool, DelayedTime delayed) {
super(pool,delayed);
this.config = config;
this.pool = pool;
this.delayed = delayed;
restApi = Forest.client(CloopenRestApi.class);
}
@ -72,74 +65,4 @@ public class CloopenSmsImpl implements SmsBlend {
paramMap.put("datas", messages.keySet().stream().map(messages::get).toArray(String[]::new));
return helper.request(restApi::sendSms, paramMap);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> sendMessage(phone, message));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone,templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> sendMessage(phone, templateId, messages));
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
}

88
sms4j-provider/src/main/java/org/dromara/sms4j/ctyun/service/CtyunSmsImpl.java
View File

@ -1,48 +1,36 @@
package org.dromara.sms4j.ctyun.service;
import com.alibaba.fastjson.JSON;
import com.dtflys.forest.config.ForestConfiguration;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.exception.SmsBlendException;
import org.dromara.sms4j.comm.factory.BeanFactory;
import org.dromara.sms4j.ctyun.config.CtyunConfig;
import org.dromara.sms4j.ctyun.utils.CtyunUtils;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
/**
* <p>类名: CtyunSmsImpl
* <p>说明： 天翼云短信实现
*
* @author :bleachhtred
* 2023/5/12 15:06
**/
@Slf4j
public class CtyunSmsImpl implements SmsBlend {
public class CtyunSmsImpl extends AbstractSmsBlend {
private final CtyunConfig ctyunConfig;
private final Executor pool;
private final DelayedTime delayed;
private final ForestConfiguration http = BeanFactory.getForestConfiguration();
public CtyunSmsImpl(CtyunConfig ctyunConfig, Executor pool, DelayedTime delayedTime) {
super(pool,delayedTime);
this.ctyunConfig = ctyunConfig;
this.pool = pool;
this.delayed = delayedTime;
}
@Override
@ -110,76 +98,6 @@ public class CtyunSmsImpl implements SmsBlend {
return smsResponse;
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> sendMessage(phone, message));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone,templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> sendMessage(phone, templateId, messages));
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
private String arrayToString(List<String> list) {
StringBuilder sb = new StringBuilder();
for (String s : list) {

89
sms4j-provider/src/main/java/org/dromara/sms4j/emay/service/EmaySmsImpl.java
View File

@ -1,22 +1,16 @@
package org.dromara.sms4j.emay.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.dtflys.forest.config.ForestConfiguration;
import com.jdcloud.sdk.utils.StringUtils;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.emay.config.EmayConfig;
import org.dromara.sms4j.emay.util.EmayBuilder;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.exception.SmsBlendException;
import org.dromara.sms4j.comm.factory.BeanFactory;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
@ -27,21 +21,14 @@ import static org.dromara.sms4j.comm.utils.SmsUtil.listToString;
* @date 2023-04-11 12:00
*/
@Slf4j
public class EmaySmsImpl implements SmsBlend {
public class EmaySmsImpl extends AbstractSmsBlend {
public EmaySmsImpl(EmayConfig config, Executor pool, DelayedTime delayed) {
super(pool,delayed);
this.config = config;
this.pool = pool;
this.delayed = delayed;
}
private EmayConfig config;
private Executor pool;
private DelayedTime delayed;
private final ForestConfiguration http = BeanFactory.getForestConfiguration();
@Override
@Restricted
public SmsResponse sendMessage(String phone, String message) {
@ -89,76 +76,6 @@ public class EmaySmsImpl implements SmsBlend {
return sendMessage(listToString(phones), EmayBuilder.listToString(list));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> sendMessage(phone, message));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> sendMessage(phone, templateId, messages));
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
private SmsResponse getSendResponse(Map<String, Object> body, String requestUrl) {
AtomicReference<SmsResponse> smsResponse = new AtomicReference<>();
http.post(requestUrl)

90
sms4j-provider/src/main/java/org/dromara/sms4j/huawei/service/HuaweiSmsImpl.java
View File

@ -1,42 +1,30 @@
package org.dromara.sms4j.huawei.service;
import com.dtflys.forest.config.ForestConfiguration;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.constant.Constant;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.factory.BeanFactory;
import org.dromara.sms4j.huawei.config.HuaweiConfig;
import org.dromara.sms4j.huawei.entity.HuaweiResponse;
import org.dromara.sms4j.huawei.utils.HuaweiBuilder;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.AbstractSmsBlend;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import static org.dromara.sms4j.huawei.utils.HuaweiBuilder.listToString;
@Slf4j
public class HuaweiSmsImpl implements SmsBlend {
public class HuaweiSmsImpl extends AbstractSmsBlend {
public HuaweiSmsImpl(HuaweiConfig config, Executor pool, DelayedTime delayed) {
super(pool,delayed);
this.config = config;
this.pool = pool;
this.delayed = delayed;
}
private HuaweiConfig config;
private Executor pool;
private DelayedTime delayed;
private final ForestConfiguration http = BeanFactory.getForestConfiguration();
@Override
@Restricted
public SmsResponse sendMessage(String phone, String message) {
@ -95,76 +83,4 @@ public class HuaweiSmsImpl implements SmsBlend {
public SmsResponse massTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages) {
return sendMessage(listToString(phones), templateId, messages);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> sendMessage(phone, message));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> {
sendMessage(phone, templateId, messages);
});
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
}

84
sms4j-provider/src/main/java/org/dromara/sms4j/jdcloud/service/JdCloudSmsImpl.java
View File

@ -5,8 +5,7 @@ import com.jdcloud.sdk.service.sms.client.SmsClient;
import com.jdcloud.sdk.service.sms.model.BatchSendRequest;
import com.jdcloud.sdk.service.sms.model.BatchSendResult;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
@ -16,8 +15,6 @@ import org.dromara.sms4j.jdcloud.config.JdCloudConfig;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.TimerTask;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;
@ -28,21 +25,16 @@ import java.util.stream.Collectors;
* @since 2023/4/10 20:01
*/
@Slf4j
public class JdCloudSmsImpl implements SmsBlend {
public class JdCloudSmsImpl extends AbstractSmsBlend {
private final SmsClient client;
private final JdCloudConfig config;
private final Executor pool;
private final DelayedTime delayed;
public JdCloudSmsImpl(SmsClient client, JdCloudConfig config, Executor pool, DelayedTime delayed) {
super(pool,delayed);
this.client = client;
this.config = config;
this.pool = pool;
this.delayed = delayed;
}
@Override
@ -85,76 +77,6 @@ public class JdCloudSmsImpl implements SmsBlend {
}
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> sendMessage(phone, message));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> sendMessage(phone, templateId, messages));
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
/**
* 获取短信返回信息
*

91
sms4j-provider/src/main/java/org/dromara/sms4j/tencent/service/TencentSmsImpl.java
View File

@ -2,38 +2,27 @@ package org.dromara.sms4j.tencent.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.dtflys.forest.config.ForestConfiguration;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.constant.Constant;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.exception.SmsBlendException;
import org.dromara.sms4j.comm.factory.BeanFactory;
import org.dromara.sms4j.tencent.config.TencentConfig;
import org.dromara.sms4j.tencent.utils.TencentUtils;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
@Slf4j
public class TencentSmsImpl implements SmsBlend {
public class TencentSmsImpl extends AbstractSmsBlend {
private TencentConfig tencentSmsConfig;
private Executor pool;
private DelayedTime delayed;
private final ForestConfiguration http = BeanFactory.getForestConfiguration();
public TencentSmsImpl(TencentConfig tencentSmsConfig, Executor pool, DelayedTime delayed) {
super(pool,delayed);
this.tencentSmsConfig = tencentSmsConfig;
this.pool = pool;
this.delayed = delayed;
}
@Override
@ -122,80 +111,6 @@ public class TencentSmsImpl implements SmsBlend {
return smsResponse;
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> {
sendMessage(phone, message);
});
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> {
sendMessage(phone, templateId, messages);
});
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
private String[] arrayToString(List<String> list) {
String[] strs = new String[list.size()];
List<String> toStr = new ArrayList<>();

84
sms4j-provider/src/main/java/org/dromara/sms4j/unisms/service/UniSmsImpl.java
View File

@ -1,7 +1,6 @@
package org.dromara.sms4j.unisms.service;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
@ -16,11 +15,7 @@ import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.function.Supplier;
/**
@ -31,16 +26,13 @@ import java.util.function.Supplier;
**/
@Slf4j
public class UniSmsImpl implements SmsBlend {
public class UniSmsImpl extends AbstractSmsBlend {
private UniConfig config;
private Executor pool;
private DelayedTime delayed;
public UniSmsImpl(UniConfig config, Executor pool, DelayedTime delayed) {
super(pool,delayed);
this.config = config;
this.pool = pool;
this.delayed = delayed;
}
@Override
@ -90,76 +82,6 @@ public class UniSmsImpl implements SmsBlend {
return getSmsResponse(data);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
public void sendMessageAsync(String phone, String message) {
pool.execute(()->{
sendMessage(phone, message);
});
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(()->{
sendMessage(phone,templateId,messages);
});
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone,message);
}
},delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone,templateId,messages);
}
},delayedTime);
}
@Override
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones,message);
}
},delayedTime);
}
@Override
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones,templateId,messages);
}
},delayedTime);
}
private SmsResponse getSmsResponse( Map<String, Object> data) {
SmsResponse smsResponse = new SmsResponse();
try {

89
sms4j-provider/src/main/java/org/dromara/sms4j/yunpian/service/YunPianSmsImpl.java
View File

@ -1,40 +1,29 @@
package org.dromara.sms4j.yunpian.service;
import com.alibaba.fastjson.JSONObject;
import com.dtflys.forest.config.ForestConfiguration;
import org.dromara.sms4j.api.SmsBlend;
import org.dromara.sms4j.api.callback.CallBack;
import org.dromara.sms4j.api.AbstractSmsBlend;
import org.dromara.sms4j.api.entity.SmsResponse;
import org.dromara.sms4j.comm.annotation.Restricted;
import org.dromara.sms4j.comm.constant.Constant;
import org.dromara.sms4j.comm.delayedTime.DelayedTime;
import org.dromara.sms4j.comm.exception.SmsBlendException;
import org.dromara.sms4j.comm.factory.BeanFactory;
import org.dromara.sms4j.yunpian.config.YunpianConfig;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
import static org.dromara.sms4j.comm.utils.SmsUtil.listToString;
public class YunPianSmsImpl implements SmsBlend {
public class YunPianSmsImpl extends AbstractSmsBlend {
public YunPianSmsImpl(Executor pool, DelayedTime delayed, YunpianConfig config) {
this.pool = pool;
this.delayed = delayed;
super(pool,delayed);
this.config = config;
}
private Executor pool;
private DelayedTime delayed;
private YunpianConfig config;
private final ForestConfiguration http = BeanFactory.getForestConfiguration();
private static SmsResponse getSmsResponse(JSONObject execute) {
SmsResponse smsResponse = new SmsResponse();
if (execute == null){
@ -84,78 +73,6 @@ public class YunPianSmsImpl implements SmsBlend {
return sendMessage(listToString(phones), templateId, messages);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, message), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String message) {
pool.execute(() -> sendMessage(phone, message));
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages, CallBack callBack) {
CompletableFuture<SmsResponse> smsResponseCompletableFuture = CompletableFuture.supplyAsync(() -> sendMessage(phone, templateId, messages), pool);
smsResponseCompletableFuture.thenAcceptAsync(callBack::callBack);
}
@Override
@Restricted
public void sendMessageAsync(String phone, String templateId, LinkedHashMap<String, String> messages) {
pool.execute(() -> {
sendMessage(phone, templateId, messages);
});
}
@Override
@Restricted
public void delayedMessage(String phone, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayedMessage(String phone, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
sendMessage(phone, templateId, messages);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String message, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, message);
}
}, delayedTime);
}
@Override
@Restricted
public void delayMassTexting(List<String> phones, String templateId, LinkedHashMap<String, String> messages, Long delayedTime) {
this.delayed.schedule(new TimerTask() {
@Override
public void run() {
massTexting(phones, templateId, messages);
}
}, delayedTime);
}
private String formattingMap(Map<String, String> messages) {
StringBuilder str = new StringBuilder();
for (Map.Entry<String, String> entry : messages.entrySet()) {