lxy/zhub-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

修改：工程结构变更为 标准 maven 工程

Browse Source
This commit is contained in:
梁显优
2023-06-25 02:27:57 +08:00
parent 99cb1ea3c8
commit 9a3314e0e6
21 changed files with 36 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
src/main/java/tccn/AbstractConsumer.java Normal file
View File

@@ -0,0 +1,82 @@
package tccn;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import tccn.zhub.Rpc;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
/**
* @author Liang
* @data 2020-09-05 23:18
*/
public abstract class AbstractConsumer implements IConsumer {
public Gson gson = Rpc.gson;
// @Resource(name = "APP_NAME")
protected String APP_NAME = "";
private Map<String, EventType> eventMap = new HashMap<>();
protected abstract String getGroupid();
protected boolean preInit() {
return true;
}
protected final Set<String> getTopics() {
if (!eventMap.isEmpty()) {
return eventMap.keySet();
}
HashSet<String> set = new HashSet<>();
set.add("-");
return set;
}
protected void accept(String topic, String value) {
EventType eventType = eventMap.get(topic);
Object data = null;
if ("java.lang.String".equals(eventType.typeToken.getType().getTypeName())) {
data = value;
} else {
data = gson.fromJson(value, eventType.typeToken.getType());
}
eventType.accept(data);
}
protected final void removeEventType(String topic) {
eventMap.remove(topic);
}
/**
* 不同组件的订阅事件 发送
*
* @param topic
*/
protected abstract void subscribe(String topic);
public void subscribe(String topic, Consumer<String> consumer) {
subscribe(topic, TYPE_TOKEN_STRING, consumer);
}
@Override
public <T> void subscribe(String topic, TypeToken<T> typeToken, Consumer<T> consumer) {
if (topic.contains(",")) {
for (String x : topic.split(",")) {
subscribe(x, typeToken, consumer);
}
} else {
eventMap.put(topic, EventType.of(topic, typeToken, consumer));
subscribe(topic);
}
}
}

23
src/main/java/tccn/Event.java Normal file
View File

@@ -0,0 +1,23 @@
package tccn;
/**
* 发布订阅 事件
*
* @param <V>
*/
public class Event<V> {
public final String topic;
//public final String key;
public final V value;
private Event(String topic, V value) {
this.topic = topic;
this.value = value;
}
public static <V> Event of(String topic, V value) {
return new Event<V>(topic, value);
}
}

33
src/main/java/tccn/EventType.java Normal file
View File

@@ -0,0 +1,33 @@
package tccn;
import com.google.gson.reflect.TypeToken;
import java.util.function.Consumer;
public class EventType<T> {
public final String topic;
public final TypeToken<T> typeToken;
private final Consumer<T> consumer;
private final static TypeToken<String> stringToken = new TypeToken<String>() {
};
private EventType(String topic, TypeToken<T> typeToken, Consumer<T> consumer) {
this.topic = topic;
this.typeToken = typeToken;
this.consumer = consumer;
}
public static <T> EventType of(String topic, TypeToken<T> typeToken, Consumer<T> consumer) {
return new EventType<>(topic, typeToken, consumer);
}
public static EventType of(String topic, Consumer<String> consumer) {
return new EventType(topic, stringToken, consumer);
}
public void accept(T t) {
consumer.accept(t);
}
}

37
src/main/java/tccn/IConsumer.java Normal file
View File

@@ -0,0 +1,37 @@
package tccn;
import com.google.gson.reflect.TypeToken;
import java.util.function.Consumer;
public interface IConsumer {
TypeToken<String> TYPE_TOKEN_STRING = new TypeToken<String>() {
};
TypeToken<Integer> TYPE_TOKEN_INT = new TypeToken<Integer>() {
};
/**
* 取消订阅
*
* @param topic
*/
void unsubscribe(String topic);
/**
* 订阅， 接收数据类型 String
*
* @param topic
* @param consumer
*/
void subscribe(String topic, Consumer<String> consumer);
/**
* 订阅，接收类型为 <T>
*
* @param topic
* @param typeToken
* @param consumer
* @param <T>
*/
<T> void subscribe(String topic, TypeToken<T> typeToken, Consumer<T> consumer);
}

9
src/main/java/tccn/IProducer.java Normal file
View File

@@ -0,0 +1,9 @@
package tccn;
import java.util.logging.Logger;
public interface IProducer {
Logger logger = Logger.getLogger(IProducer.class.getSimpleName());
boolean publish(String topic, Object v);
}

21
src/main/java/tccn/IType.java Normal file
View File

@@ -0,0 +1,21 @@
package tccn;
import com.google.gson.reflect.TypeToken;
import java.util.List;
import java.util.Map;
public interface IType {
TypeToken<String> STRING = new TypeToken<String>() {
};
TypeToken<Integer> INT = new TypeToken<Integer>() {
};
TypeToken<Map<String, String>> MAP = new TypeToken<Map<String, String>>() {
};
TypeToken<List<Map<String, String>>> LMAP = new TypeToken<List<Map<String, String>>>() {
};
}

66
src/main/java/tccn/timer/TimerExecutor.java Normal file
View File

@@ -0,0 +1,66 @@
package tccn.timer;
import tccn.timer.queue.TimerQueue;
import tccn.timer.task.Task;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
/**
* @author: liangxianyou
*/
public class TimerExecutor {
private Logger logger = Logger.getLogger(this.getClass().getSimpleName());
private TimerQueue queue = new TimerQueue();
private ExecutorService executor;
public TimerExecutor(int n) {
executor = Executors.newFixedThreadPool(n);
start();
}
public void add(Task... task) {
for (Task t : task) {
t.setTimerExecutor(this);
queue.push(t);
logger.finest("add new task : " + t.getName());
}
}
protected void add(Task task, boolean upTime) {
task.setTimerExecutor(this);
if (upTime) task.nextTime();
queue.push(task);
}
public Task remove(String name) {
return queue.remove(name);
}
public Task get(String name) {
return queue.get(name);
}
public void start() {
new Thread(() -> {
while (true) {
try {
Task take = null;
try {
take = queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
//执行调度
executor.execute(take);
//add(take, true); //继续添加任务到 队列
} catch (Exception e) {
e.printStackTrace();
}
}
}, "Thread-Redtimer-0").start();
}
}

108
src/main/java/tccn/timer/TimerTask.java Normal file
View File

@@ -0,0 +1,108 @@
package tccn.timer;
import tccn.timer.scheduled.Scheduled;
import tccn.timer.task.Job;
import tccn.timer.task.Task;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
/**
* Created by liangxianyou at 2018/7/23 14:33.
*/
public class TimerTask implements Task {
private Logger logger = Logger.getLogger(this.getClass().getSimpleName());
private long startTime = System.currentTimeMillis();
private AtomicInteger execCount = new AtomicInteger();
protected String name;
private long theTime;
private Scheduled scheduled;
private boolean isComplete;
private TimerExecutor timerExecutor;
private Job job;
public static Task by(String name, Scheduled scheduled, Job job) {
TimerTask task = new TimerTask();
task.name = name;
task.scheduled = scheduled;
task.job = job;
return task;
}
@Override
public String getName() {
return name;
}
@Override
public void setScheduled(Scheduled scheduled) {
this.scheduled = scheduled;
//this.theTime = Date.from(scheduled.theTime().atZone(ZoneId.systemDefault()).toInstant()).getTime();
}
@Override
public long nextTime() {
LocalDateTime next = scheduled.nextTime();
this.theTime = Date.from(next.atZone(ZoneId.systemDefault()).toInstant()).getTime();
/*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("下次执行:"+ sdf.format(next.toInstant(ZoneOffset.of("+8")).toEpochMilli()));*/
return theTime;
}
@Override
public long theTime() {
LocalDateTime next = scheduled.theTime();
this.theTime = Date.from(next.atZone(ZoneId.systemDefault()).toInstant()).getTime();
return theTime;
}
@Override
public boolean isComplete() {
return isComplete;
}
public void setComplete(boolean complete) {
if (isComplete = complete)
timerExecutor.remove(name);
}
public int getExecCount() {
return execCount.get();
}
public TimerExecutor getTimerExecutor() {
return timerExecutor;
}
public void setTimerExecutor(TimerExecutor timerExecutor) {
this.timerExecutor = timerExecutor;
}
public long startTime() {
return startTime;
}
@Override
public void run() {
//没有完成任务，继续执行
if (!isComplete) {
int count = execCount.incrementAndGet(); // 执行次数+1
long start = System.currentTimeMillis();
job.execute(this);
long end = System.currentTimeMillis();
logger.finest(String.format("task [%s] : not complete -> %s, time: %s ms, exec count: %s.", getName(), isComplete ? "had complete" : "not complete", end - start, count));
if (!isComplete) {
timerExecutor.add(this, true);
}
}
}
}

40
src/main/java/tccn/timer/Timers.java Normal file
View File

@@ -0,0 +1,40 @@
package tccn.timer;
import tccn.timer.scheduled.ScheduledCycle;
import java.util.UUID;
import java.util.function.Supplier;
public class Timers {
private static final TimerExecutor timerExecutor = new TimerExecutor(1);
/**
* 本地延时重试
*/
public static void tryDelay(Supplier<Boolean> supplier, long millis, int maxCount) {
timerExecutor.add(TimerTask.by("try-delay-task-" + UUID.randomUUID().toString().replaceAll("-", ""), ScheduledCycle.of(0), task -> {
if (supplier.get() || task.getExecCount() == maxCount) {
task.setComplete(true);
}
if (task.getExecCount() == 1) {
task.setScheduled(ScheduledCycle.of(millis));
}
}));
}
/**
* 本地延时：延时时间极短的场景下使用 （如：1分钟内）
*/
public static void delay(Runnable runnable, long millis) {
timerExecutor.add(TimerTask.by("delay-task-" + UUID.randomUUID().toString().replaceAll("-", ""), ScheduledCycle.of(millis), task -> {
runnable.run();
task.setComplete(true);
}));
}
}

105
src/main/java/tccn/timer/queue/TimerQueue.java Normal file
View File

@@ -0,0 +1,105 @@
package tccn.timer.queue;
import tccn.timer.task.Task;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* Created by liangxianyou at 2018/7/23 14:07.
*/
public class TimerQueue {
private ReentrantLock lock = new ReentrantLock();
private Condition isEmpty = lock.newCondition();
private LinkedList<Task> queue = new LinkedList();
/**
* 新加调度任务
*
* @param task
*/
public void push(Task task) {
try {
lock.lock();
remove(task.getName());
int inx = queue.size();//目标坐标
while (inx > 0 && queue.get(inx - 1).theTime() > task.theTime()) {
inx--;
}
queue.add(inx, task);
isEmpty.signal();
} finally {
lock.unlock();
}
}
/**
* 调度等待执行的任务
*
* @return
* @throws InterruptedException
*/
public Task take() throws InterruptedException {
try {
lock.lock();
while (queue.size() == 0) {
isEmpty.await();
}
long currentTime = System.currentTimeMillis();
long nextTime = queue.getFirst().theTime();
if (currentTime >= nextTime) {
return queue.removeFirst();
} else {
isEmpty.await(nextTime - currentTime, TimeUnit.MILLISECONDS);
return take();
}
} finally {
lock.unlock();
}
}
/**
* 删除指定名称的任务
*
* @param name
* @return
*/
public Task remove(String name) {
return get(name, true);
}
/**
* 返回指定名称的任务
*
* @param name
* @return
*/
public Task get(String name) {
return get(name, false);
}
private Task get(String name, boolean remove) {
try {
lock.lock();
Task take = null;
for (int i = 0; i < queue.size(); i++) {
if (name.equals(queue.get(i).getName())) {
take = queue.get(i);
}
}
if (remove && take != null) {
queue.remove(take);
}
isEmpty.signal();
return take;
} finally {
lock.unlock();
}
}
}

23
src/main/java/tccn/timer/scheduled/Scheduled.java Normal file
View File

@@ -0,0 +1,23 @@
package tccn.timer.scheduled;
import java.time.LocalDateTime;
/**
* @author: liangxianyou at 2018/8/5 17:35.
*/
public interface Scheduled {
/**
* 下次执行时间
*
* @return
*/
LocalDateTime nextTime();
/**
* 当前执行时间
*
* @return
*/
LocalDateTime theTime();
}

79
src/main/java/tccn/timer/scheduled/ScheduledCycle.java Normal file
View File

@@ -0,0 +1,79 @@
package tccn.timer.scheduled;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalUnit;
/**
* @author: liangxianyou at 2018/8/5 18:05.
*/
public class ScheduledCycle implements Scheduled {
private LocalDateTime theTime;
private long period;
private TemporalUnit unit = ChronoUnit.MILLIS;
private ScheduledCycle() {
}
public static Scheduled of(String periodCfg) {
TemporalUnit unit = ChronoUnit.MILLIS;
String endchar = "";
long period;
if (periodCfg.matches("^\\d+[y,M,d,H,m,s]$")) {
endchar = periodCfg.substring(periodCfg.length() - 1);
period = Long.parseLong(periodCfg.substring(0, periodCfg.length() - 1));
} else if (periodCfg.matches("^\\d+$")) {
period = Long.parseLong(periodCfg);
if (period <= 0) {
throw new IllegalArgumentException(String.format("ScheduledCycle period config error: [%s]", periodCfg));
}
} else {
throw new IllegalArgumentException(String.format("ScheduledCycle period config error: [%s]", periodCfg));
}
if ("y".equals(endchar)) unit = ChronoUnit.YEARS;
else if ("M".equals(endchar)) unit = ChronoUnit.MONTHS;
else if ("d".equals(endchar)) unit = ChronoUnit.DAYS;
else if ("H".equals(endchar)) unit = ChronoUnit.HOURS;
else if ("m".equals(endchar)) unit = ChronoUnit.MINUTES;
else if ("s".equals(endchar)) unit = ChronoUnit.SECONDS;
return of(period, unit);
}
public static Scheduled of(long period) {
return of(period, ChronoUnit.MILLIS);
}
public static Scheduled of(long period, TemporalUnit unit) {
LocalDateTime theTime = LocalDateTime.now().plus(period, unit);
return of(theTime, period, unit);
}
public static Scheduled of(LocalDateTime startTime, long period) {
return of(startTime, period, ChronoUnit.MILLIS);
}
public static Scheduled of(LocalDateTime startTime, long period, TemporalUnit unit) {
ScheduledCycle scheduled = new ScheduledCycle();
scheduled.theTime = startTime;
scheduled.period = period;
scheduled.unit = unit;
return scheduled;
}
@Override
public LocalDateTime nextTime() {
if (theTime.isAfter(LocalDateTime.now())) {
return theTime;
}
return theTime = theTime.plus(period, unit);
}
@Override
public LocalDateTime theTime() {
return theTime;
}
}

499
src/main/java/tccn/timer/scheduled/ScheduledExpres.java Normal file
View File

@@ -0,0 +1,499 @@
package tccn.timer.scheduled;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 时间解析器
*
* @author: liangxianyou
*/
@SuppressWarnings("Duplicates")
public class ScheduledExpres implements Scheduled {
private int year;
private int month;
private int[] minutes;
private int[] hours;
private int[] days;
private int[] monthes;
private int[] weeks;
private String cfg;
private String[] cfgArr;
private LocalDateTime theTime;
private int _y, _M, _d, _H, _m;
@Deprecated
private ScheduledExpres(String cfg) {
this.cfg = cfg;
this.theTime = LocalDateTime.now();
initTheTime();
}
@Deprecated
private ScheduledExpres(final LocalDateTime startTime, String cfg) {
LocalDateTime now = LocalDateTime.now();
this.theTime = now.isAfter(startTime) ? now : startTime;
this.cfg = cfg;
initTheTime();
}
public static Scheduled of(String cfg) {
return new ScheduledExpres(cfg);
}
public static Scheduled of(final LocalDateTime startTime, String cfg) {
return new ScheduledExpres(startTime, cfg);
}
//寻找初始合法时间
public void initTheTime() {
year = theTime.getYear();
month = theTime.getMonthValue();
cfgArr = cfg.split(" ");
setWeeks();
setMonthes();
setDays();
setHours();
setMinutes();
_y = theTime.getYear();
_M = theTime.getMonthValue();
_d = theTime.getDayOfMonth();
_H = theTime.getHour();
_m = theTime.getMinute();
String cmd = "";//y M d H m
if (days.length == 0) cmd = "M";
do {
carry(cmd);
int inx;
if ((inx = nowOk(monthes, _M)) < 0) {
cmd = "y";
continue;
}
_M = monthes[inx];
if ((inx = nowOk(days, _d)) < 0) {
cmd = "M";
continue;
}
_d = days[inx];
if ((inx = nowOk(hours, _H)) < 0) {
cmd = "d";
continue;
}
_H = hours[inx];
if ((inx = nowOk(minutes, _m)) < 0) {
cmd = "H";
continue;
}
_m = minutes[inx];
break;
} while (true);
theTime = LocalDateTime.of(_y, _M, _d, _H, _m);
LocalDateTime now = LocalDateTime.now();
while (theTime.isBefore(now)) {
theTime = carry("m");
}
}
/**
* 下一次执行的时间
*
* @return
*/
@Override
public LocalDateTime nextTime() {
if (theTime.isAfter(LocalDateTime.now())) {
return theTime;
}
return theTime = carry("m");
}
@Override
public LocalDateTime theTime() {
return theTime;
}
/**
* 通过发送指令进行进位
*
* @param cmd 进位指令
*/
private LocalDateTime carry(String cmd) {
int inx;
while (!"".equals(cmd)) {
switch (cmd) {
case "y":
_y = this.year = ++_y;
_M = this.month = monthes[0];
setDays();
if (days.length == 0) {
cmd = "M";
continue;
}
_d = days[0];
_H = hours[0];
_m = minutes[0];
break;
case "M":
if (_M < monthes[0]) {
_M = monthes[0];
break;
}
inx = Arrays.binarySearch(monthes, _M);
if (inx < 0 || inx >= monthes.length - 1) {
cmd = "y";
continue;
}
_M = this.month = monthes[inx + 1];
setDays();
if (days.length == 0) {
cmd = "M";
continue;
}
_d = days[0];
_H = hours[0];
_m = minutes[0];
break;
case "d":
if (_d < days[0]) {
_d = days[0];
break;
}
inx = Arrays.binarySearch(days, _d);
if (inx < 0 || inx >= days.length - 1) {
cmd = "M";
continue;
}
_d = days[inx + 1];
_H = hours[0];
_m = minutes[0];
break;
case "H":
if (_H < hours[0]) {
_H = hours[0];
break;
}
inx = Arrays.binarySearch(hours, _H);
if (inx < 0 || inx >= hours.length - 1) {
cmd = "d";
continue;
}
_H = hours[inx + 1];
_m = minutes[0];
break;
case "m":
if (_m < minutes[0]) {
_m = minutes[0];
break;
}
inx = Arrays.binarySearch(minutes, _m);
if (inx < 0 || inx >= minutes.length - 1) {
cmd = "H";
continue;
}
_m = minutes[inx + 1];
break;
}
cmd = "";
}
return LocalDateTime.of(_y, _M, _d, _H, _m);
}
/**
* 得到初始合法时间的索引
*
* @param arr 合法时间序列
* @param n 初始选中值
* @return 合法时间的索引
*/
private int nowOk(int[] arr, int n) {
if (arr == null || arr.length == 0) return -1;
if (arr[0] > n)
return 0;
if (arr[arr.length - 1] < n)
return 0;
if (arr[arr.length - 1] == n)
return arr.length - 1;
for (int i = 0; i < arr.length - 1; i++) {
if ((arr[i] < n && arr[i + 1] > n) || arr[i] == n) {
return i;
}
}
return -1;
}
/**
* 以下为 初始化合法时间 weeks，monthes，days，hour，minutes 序列
*/
private void setMinutes() {
String cfg = cfgArr[0];
if ("*".equals(cfg)) {//*
minutes = new int[60];
for (int i = 0; i < 60; i++) {
minutes[i] = i;
}
} else if (cfg.matches("^[0-5]??[0-9]??$")) {//n
minutes = new int[1];
minutes[0] = Integer.parseInt(cfg);
} else if (cfg.matches("^[*]/[0-9]+$")) {// */5
String[] strArr = cfg.split("/");
int p = Integer.parseInt(strArr[1]);
minutes = new int[60 / p];
for (int i = 0; i < minutes.length; i++) {
minutes[i] = i * p;
}
} else if (cfg.matches("^([0-5]??[0-9]??,)+([0-5]??[0-9]??)?$")) {//1,3
String[] strings = cfg.split(",");
minutes = new int[strings.length];
for (int i = 0; i < strings.length; i++) {
minutes[i] = Integer.parseInt(strings[i]);
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??$")) {//1-3
String[] split = cfg.split("-");
int s = Integer.parseInt(split[0]);
int e = Integer.parseInt(split[1]);
minutes = new int[e - s + 1];
for (int i = 0; i < minutes.length; i++) {
minutes[i] = s + i;
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??/[0-5]??[0-9]??$")) {//3-18/5
String[] strArr = cfg.split("/");
String[] str2Arr = strArr[0].split("-");
int s = Integer.parseInt(str2Arr[0]);
int e = Integer.parseInt(str2Arr[1]);
int p = Integer.parseInt(strArr[1]);
minutes = new int[(e - s) / p];
for (int i = 0; i < minutes.length; i++) {
minutes[i] = s + i * p;
}
}
}
private void setHours() {
String cfg = cfgArr[1];
if ("*".equals(cfg)) {//*
hours = new int[24];
for (int i = 0; i < hours.length; i++) {
hours[i] = i;
}
} else if (cfg.matches("^[0-5]??[0-9]??$")) {//n
hours = new int[1];
hours[0] = Integer.parseInt(cfg);
} else if (cfg.matches("^[*]/[0-9]+$")) {// */5
String[] strArr = cfg.split("/");
int p = Integer.parseInt(strArr[1]);
hours = new int[24 / p];
for (int i = 0; i < hours.length; i++) {
hours[i] = i * p;
}
} else if (cfg.matches("^([0-5]??[0-9]??,)+([0-5]??[0-9]??)?$")) {//1,3
String[] strArr = cfg.split(",");
hours = new int[strArr.length];
for (int i = 0; i < strArr.length; i++) {
hours[i] = Integer.parseInt(strArr[i]);
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??$")) {//1-3
String[] split = cfg.split("-");
int s = Integer.parseInt(split[0]);
int e = Integer.parseInt(split[1]);
hours = new int[e - s + 1];
for (int i = 0; i < hours.length; i++) {
hours[i] = s + i;
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??/[0-5]??[0-9]??$")) {//3-18/5
String[] strArr = cfg.split("/");
String[] str2Arr = strArr[0].split("-");
int s = Integer.parseInt(str2Arr[0]);
int e = Integer.parseInt(str2Arr[1]);
int p = Integer.parseInt(strArr[1]);
hours = new int[(e - s) / p];
for (int i = 0; i < hours.length; i++) {
hours[i] = s + i * p;
}
}
}
private void setWeeks() {
String cfg = cfgArr[4];
if ("*".equals(cfg)) {//*
weeks = new int[7];
for (int i = 0; i < weeks.length; i++) {
weeks[i] = i + 1;
}
} else if (cfg.matches("^[0-5]??[0-9]??$")) {//n
weeks = new int[1];
weeks[0] = Integer.parseInt(cfg);
} else if (cfg.matches("^[*]/[0-9]+$")) {// */5
String[] strArr = cfg.split("/");
int p = Integer.parseInt(strArr[1]);
weeks = new int[7 / p];
for (int i = 0; i < weeks.length; i++) {
weeks[i] = i * p;
}
} else if (cfg.matches("^([0-5]??[0-9]??,)+([0-5]??[0-9]??)?$")) {//1,3
String[] strArr = cfg.split(",");
weeks = new int[strArr.length];
for (int i = 0; i < strArr.length; i++) {
weeks[i] = Integer.parseInt(strArr[i]);
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??$")) {//1-3
String[] split = cfg.split("-");
int s = Integer.parseInt(split[0]);
int e = Integer.parseInt(split[1]);
weeks = new int[e - s + 1];
for (int i = 0; i < weeks.length; i++) {
weeks[i] = s + i;
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??/[0-5]??[0-9]??$")) {//3-18/5
String[] strArr = cfg.split("/");
String[] str2Arr = strArr[0].split("-");
int s = Integer.parseInt(str2Arr[0]);
int e = Integer.parseInt(str2Arr[1]);
int p = Integer.parseInt(strArr[1]);
weeks = new int[(e - s) / p];
for (int i = 0; i < weeks.length; i++) {
weeks[i] = s + i * p;
}
}
}
private void setMonthes() {
String cfg = cfgArr[3];
if ("*".equals(cfg)) {//*
monthes = new int[12];
for (int i = 0; i < monthes.length; i++) {
monthes[i] = i + 1;
}
} else if (cfg.matches("^[0-5]??[0-9]??$")) {//n
monthes = new int[1];
monthes[0] = Integer.parseInt(cfg);
} else if (cfg.matches("^[*]/[0-9]+$")) {// */5
String[] strArr = cfg.split("/");
int p = Integer.parseInt(strArr[1]);
monthes = new int[12 / p];
for (int i = 0; i < monthes.length; i++) {
monthes[i] = i * p;
}
} else if (cfg.matches("^([0-5]??[0-9]??,)+([0-5]??[0-9]??)?$")) {//1,3
String[] strArr = cfg.split(",");
monthes = new int[strArr.length];
for (int i = 0; i < strArr.length; i++) {
monthes[i] = Integer.parseInt(strArr[i]);
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??$")) {//1-3
String[] split = cfg.split("-");
int s = Integer.parseInt(split[0]);
int e = Integer.parseInt(split[1]);
monthes = new int[e - s + 1];
for (int i = 0; i < monthes.length; i++) {
monthes[i] = s + i;
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??/[0-5]??[0-9]??$")) {//3-18/5
String[] strArr = cfg.split("/");
String[] str2Arr = strArr[0].split("-");
int s = Integer.parseInt(str2Arr[0]);
int e = Integer.parseInt(str2Arr[1]);
int p = Integer.parseInt(strArr[1]);
monthes = new int[(e - s) / p];
for (int i = 0; i < monthes.length; i++) {
monthes[i] = s + i * p;
}
}
}
private void setDays() {
String cfg = cfgArr[2];
//当前月份总天数，
LocalDate firstDay = LocalDate.of(year, month, 1);
int lengthOfMonth = firstDay.lengthOfMonth();
if ("*".equals(cfg)) {//*
days = new int[lengthOfMonth];
for (int i = 0; i < days.length; i++) {
days[i] = i + 1;
}
} else if (cfg.matches("^[0-5]??[0-9]??$")) {//n
days = new int[1];
days[0] = Integer.parseInt(cfg);
} else if (cfg.matches("^[*]/[0-9]+$")) {// */5
String[] strArr = cfg.split("/");
int p = Integer.parseInt(strArr[1]);
days = new int[lengthOfMonth / p];
for (int i = 0; i < days.length; i++) {
days[i] = i * p;
}
} else if (cfg.matches("^([0-5]??[0-9]??,)+([0-5]??[0-9]??)?$")) {//1,3
String[] strArr = cfg.split(",");
days = new int[strArr.length];
for (int i = 0; i < strArr.length; i++) {
days[i] = Integer.parseInt(strArr[i]);
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??$")) {//1-3
String[] split = cfg.split("-");
int s = Integer.parseInt(split[0]);
int e = Integer.parseInt(split[1]);
days = new int[e - s + 1];
for (int i = 0; i < days.length; i++) {
days[i] = s + i;
}
} else if (cfg.matches("^[0-5]??[0-9]??\\-[0-5]??[0-9]??/[0-5]??[0-9]??$")) {//3-18/5
String[] strArr = cfg.split("/");
String[] str2Arr = strArr[0].split("-");
int s = Integer.parseInt(str2Arr[0]);
int e = Integer.parseInt(str2Arr[1]);
int p = Integer.parseInt(strArr[1]);
days = new int[(e - s) / p];
for (int i = 0; i < days.length; i++) {
days[i] = s + i * p;
}
}
int firstWeek = firstDay.getDayOfWeek().getValue();
List<Integer> allDay = new ArrayList<>();
for (int i = 0; i < days.length; i++) {
//int week = 7 - Math.abs(i - firstWeek) % 7;//当前星期X
int week;
int d = days[i];
if (d + firstWeek <= 8) {
week = firstWeek + d - 1;
} else {
week = (d - (8 - firstWeek)) % 7;
if (week == 0) week = 7;
}
//System.out.printf("M:%s,d:%s,w:%s%n", month, d, week);
if (Arrays.binarySearch(weeks, week) > -1) {
allDay.add(d);//加入日期
}
}
days = new int[allDay.size()];
for (int i = 0; i < allDay.size(); i++) {
days[i] = allDay.get(i);
}
}
}

14
src/main/java/tccn/timer/task/Job.java Normal file
View File

@@ -0,0 +1,14 @@
package tccn.timer.task;
/**
* @author: liangxianyou at 2018/12/8 17:24.
*/
@FunctionalInterface
public interface Job {
/**
* 任务执行的内容
*/
void execute(Task task);
}

70
src/main/java/tccn/timer/task/Task.java Normal file
View File

@@ -0,0 +1,70 @@
package tccn.timer.task;
import tccn.timer.TimerExecutor;
import tccn.timer.scheduled.Scheduled;
/**
* @author: liangxianyou at 2018/8/5 19:32.
*/
public interface Task extends Runnable {
/**
* 得到任务名称
*
* @return
*/
String getName();
/**
* 设置任务执行计划
*
* @param scheduled
*/
void setScheduled(Scheduled scheduled);
/**
* 得到下一次执行计划的时间，并设置thenTime
*
* @return
*/
long nextTime();
/**
* 任务即将执行的时间点
*
* @return
*/
long theTime();
/**
* 是否完成
*
* @return
*/
boolean isComplete();
/**
* 完成任务(结束标记)
*
* @param complete
*/
void setComplete(boolean complete);
/**
* 开始时间（创建时间）
*
* @return
*/
long startTime();
TimerExecutor getTimerExecutor();
void setTimerExecutor(TimerExecutor timerExecutor);
/**
* 得到总执行次数
*
* @return
*/
int getExecCount();
}

20
src/main/java/tccn/zhub/Lock.java Normal file
View File

@@ -0,0 +1,20 @@
package tccn.zhub;
// ================================================== lock ==================================================
public class Lock {
private String name;
private String uuid;
private int duration;
private ZHubClient hubClient;
protected Lock(String name, String uuid, int duration, ZHubClient hubClient) {
this.name = name;
this.uuid = uuid;
this.duration = duration;
this.hubClient = hubClient;
}
public void unLock() {
hubClient.send("unlock", name, uuid);
}
}

93
src/main/java/tccn/zhub/Rpc.java Normal file
View File

@@ -0,0 +1,93 @@
package tccn.zhub;
import com.google.gson.Gson;
import com.google.gson.annotations.Expose;
public class Rpc<T> {
/*public final static Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.create();*/
public final static Gson gson = new Gson();
private String ruk; // request unique key:
private String topic; // call topic
private T value; // call paras
@Expose(deserialize = false, serialize = false)
private RpcResult rpcResult;
public Rpc() {
}
public Rpc(String appname, String ruk, String topic, Object value) {
this.ruk = appname + "::" + ruk;
this.topic = topic;
this.value = (T) gson.toJson(value);
}
public String getRuk() {
return ruk;
}
public void setRuk(String ruk) {
this.ruk = ruk;
}
public String getTopic() {
return topic;
}
public void setTopic(String topic) {
this.topic = topic;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public RpcResult getRpcResult() {
return rpcResult;
}
public void setRpcResult(RpcResult rpcResult) {
this.rpcResult = rpcResult;
}
public String getBackTopic() {
return ruk.split("::")[0];
}
public <R> RpcResult<R> buildResp() {
RpcResult<R> response = new RpcResult<>();
response.setRuk(ruk);
return response;
}
public <R> RpcResult<R> buildResp(int retcode, String retinfo) {
RpcResult<R> response = new RpcResult<>();
response.setRuk(ruk);
response.setRetcode(retcode);
response.setRetinfo(retinfo);
return response;
}
public <R> RpcResult<R> buildError(String retinfo) {
RpcResult<R> response = new RpcResult<>();
response.setRuk(ruk);
response.setRetcode(100);
response.setRetinfo(retinfo);
return response;
}
public <R> RpcResult<R> buildResp(R result) {
RpcResult<R> response = new RpcResult<>();
response.setRuk(ruk);
response.setResult(result);
return response;
}
}

40
src/main/java/tccn/zhub/RpcResult.java Normal file
View File

@@ -0,0 +1,40 @@
package tccn.zhub;
public class RpcResult<R> {
private String ruk;
private int retcode;
private String retinfo;
private R result;
public String getRuk() {
return ruk;
}
public void setRuk(String ruk) {
this.ruk = ruk;
}
public int getRetcode() {
return retcode;
}
public void setRetcode(int retcode) {
this.retcode = retcode;
}
public String getRetinfo() {
return retinfo;
}
public void setRetinfo(String retinfo) {
this.retinfo = retinfo;
}
public R getResult() {
return result;
}
public void setResult(R result) {
this.result = result;
}
}

643
src/main/java/tccn/zhub/ZHubClient.java Normal file
View File

@@ -0,0 +1,643 @@
package tccn.zhub;
import com.google.gson.reflect.TypeToken;
import tccn.AbstractConsumer;
import tccn.Event;
import tccn.IConsumer;
import tccn.IProducer;
import tccn.timer.Timers;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ZHubClient extends AbstractConsumer implements IConsumer, IProducer {
public Logger logger = Logger.getLogger(ZHubClient.class.getSimpleName());
private String addr = "127.0.0.1:1216";
//private String password = "";
private String groupid = "";
private String auth = "";
private OutputStream writer;
private BufferedReader reader;
private final LinkedBlockingQueue<Timer> timerQueue = new LinkedBlockingQueue<>();
private final LinkedBlockingQueue<Event<String>> topicQueue = new LinkedBlockingQueue<>();
private final LinkedBlockingQueue<Event<String>> rpcBackQueue = new LinkedBlockingQueue<>(); // RPC BACK MSG
private final LinkedBlockingQueue<Event<String>> rpcCallQueue = new LinkedBlockingQueue<>(); // RPC CALL MSG
private final LinkedBlockingQueue<String> sendMsgQueue = new LinkedBlockingQueue<>(); // SEND MSG
private final BiConsumer<Runnable, Integer> threadBuilder = (r, n) -> {
for (int i = 0; i < n; i++) {
new Thread(() -> r.run()).start();
}
};
/*private static boolean isFirst = true;
private boolean isMain = false;*/
private static final Map<String, ZHubClient> mainHub = new HashMap<>(); // 127.0.0.1:1216 - ZHubClient
public ZHubClient(String addr, String groupid, String appname, String auth) {
this.addr = addr;
this.groupid = groupid;
this.APP_NAME = appname;
this.auth = auth;
init(null);
}
public void init(Map<String, String> config) {
if (!preInit()) {
return;
}
// 自动注入
if (config != null) {
addr = config.getOrDefault("addr", addr);
groupid = config.getOrDefault("groupid", groupid);
APP_NAME = config.getOrDefault("appname", APP_NAME);
}
// 设置第一个启动的 实例为主实例
/*if (isFirst) {
isMain = true;
isFirst = false;
}*/
if (!mainHub.containsKey(addr)) { // 确保同步执行此 init 逻辑
mainHub.put(addr, this);
}
if (!initSocket(0)) {
return;
}
// 消息 事件接收
new Thread(() -> {
while (true) {
try {
String readLine = reader.readLine();
if (readLine == null && initSocket(Integer.MAX_VALUE)) { // 连接中断 处理
continue;
}
String type;
// +ping
if ("+ping".equals(readLine)) {
send("+pong");
continue;
}
// 主题订阅消息
if ("*3".equals(readLine)) {
reader.readLine(); // $7 len()
type = reader.readLine(); // message
if (!"message".equals(type)) {
continue;
}
reader.readLine(); //$n len(key)
String topic = reader.readLine(); // topic
String lenStr = reader.readLine();//$n len(value)
int clen = 0;
if (lenStr.startsWith("$")) {
clen = Integer.parseInt(lenStr.replace("$", ""));
}
String value = "";
do {
if (value.length() > 0) {
value += "\r\n";
}
String s = reader.readLine();
value += s; // value
} while (clen > 0 && clen > strLength(value));
// lock msg
if ("lock".equals(topic)) {
Lock lock = lockTag.get(value);
if (lock != null) {
synchronized (lock) {
lock.notifyAll();
}
}
continue;
}
// rpc back msg
if (APP_NAME.equals(topic)) {
rpcBackQueue.add(Event.of(topic, value));
continue;
}
// rpc call msg
if (rpcTopics.contains(topic)) {
rpcCallQueue.add(Event.of(topic, value));
continue;
}
// oth msg
topicQueue.add(Event.of(topic, value));
continue;
}
// timer 消息
if ("*2".equals(readLine)) {
reader.readLine(); // $7 len()
type = reader.readLine(); // message
if (!"timer".equals(type)) {
continue;
}
reader.readLine(); //$n len(key)
String topic = reader.readLine(); // name
timerQueue.add(timerMap.get(topic));
continue;
}
logger.finest(readLine);
} catch (IOException e) {
if (e instanceof SocketException) {
initSocket(Integer.MAX_VALUE);
}
e.printStackTrace();
}
}
}).start();
// 定时调度事件
threadBuilder.accept(() -> {
while (true) {
Timer timer = null;
try {
if ((timer = timerQueue.take()) == null) {
return;
}
long start = System.currentTimeMillis();
timer.runnable.run();
long end = System.currentTimeMillis();
logger.finest(String.format("timer [%s] : elapsed time %s ms", timer.name, end - start));
} catch (InterruptedException e) {
e.printStackTrace();
} catch (Exception e) {
logger.log(Level.WARNING, "timer [" + timer.name + "]", e);
}
}
}, 1);
// topic msg
threadBuilder.accept(() -> {
while (true) {
Event<String> event = null;
try {
if ((event = topicQueue.take()) == null) {
continue;
}
logger.log(Level.FINE, "topic[" + event.topic + "] :" + event.value);
accept(event.topic, event.value);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (Exception e) {
logger.log(Level.WARNING, "topic[" + event.topic + "] event accept error :" + event.value, e);
}
}
}, 1);
// rpc back
threadBuilder.accept(() -> {
while (true) {
Event<String> event = null;
try {
if ((event = rpcBackQueue.take()) == null) {
continue;
}
//if (event)
logger.info(String.format("rpc-back:[%s]: %s", event.topic, event.value));
rpcAccept(event.value);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (Exception e) {
logger.log(Level.WARNING, "rpc-back[" + event.topic + "] event accept error :" + event.value, e);
}
}
}, 1);
// rpc call
threadBuilder.accept(() -> {
while (true) {
Event<String> event = null;
try {
if ((event = rpcCallQueue.take()) == null) {
continue;
}
logger.info(String.format("rpc-call:[%s] %s", event.topic, event.value));
accept(event.topic, event.value);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (Exception e) {
logger.log(Level.WARNING, "rpc-call[" + event.topic + "] event accept error :" + event.value, e);
}
}
}, 1);
// send msg
threadBuilder.accept(() -> {
while (true) {
String msg = null;
try {
if ((msg = sendMsgQueue.take()) == null) {
continue;
}
// logger.log(Level.FINEST, "send-msg: [" + msg + "]");
writer.write(msg.getBytes());
writer.flush();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (Exception e) {
logger.log(Level.WARNING, "send-msg[" + msg + "] event accept error :", e);
}
}
}, 1);
}
// ---------------------
// -- 消息发送 --
protected boolean send(String... data) {
if (data.length == 1) {
sendMsgQueue.add(data[0] + "\r\n");
} else if (data.length > 1) {
StringBuilder buf = new StringBuilder();
buf.append("*" + data.length + "\r\n");
for (String d : data) {
buf.append("$" + strLength(d) + "\r\n");
buf.append(d + "\r\n");
}
sendMsgQueue.add(buf.toString());
}
return true;
}
/*protected boolean send(String... data) {
try {
lock.lock();
if (data.length == 1) {
writer.write((data[0] + "\r\n").getBytes());
} else if (data.length > 1) {
writer.write(("*" + data.length + "\r\n").getBytes());
for (String d : data) {
writer.write(("$" + d.length() + "\r\n").getBytes());
writer.write((d + "\r\n").getBytes());
}
}
writer.flush();
return true;
} catch (IOException e) {
logger.log(Level.WARNING, "", e);
} finally {
lock.unlock();
}
return false;
}*/
private int strLength(String str) {
str = str.replaceAll("[^\\x00-\\xff]", "*");
return str.length();
}
private String toStr(Object v) {
if (v instanceof String) {
return (String) v;
} else if (v == null) {
return null;
}
return gson.toJson(v);
}
protected boolean initSocket(int retry) {
for (int i = 0; i <= retry; i++) {
try {
String[] hostPort = addr.split(":");
String host = hostPort[0];
int port = Integer.parseInt(hostPort[1]);
//private ReentrantLock lock = new ReentrantLock();
Socket client = new Socket();
client.connect(new InetSocketAddress(host, port));
client.setKeepAlive(true);
writer = client.getOutputStream();
reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
String groupid = getGroupid();
if (groupid == null || groupid.isEmpty()) {
throw new RuntimeException("ZHubClient groupid can not is empty");
}
send("auth", auth);
send("groupid " + groupid);
StringBuffer buf = new StringBuffer("subscribe lock");
/*if (isMain) {
}*/
if (mainHub.containsValue(this)) {
buf.append(" ").append(APP_NAME);
}
for (String topic : getTopics()) {
buf.append(" ").append(topic);
}
send(buf.toString());
// 重连 timer 订阅
timerMap.forEach((name, timer) -> send("timer", name));
if (retry > 0) {
logger.warning(String.format("ZHubClient[%s][%s] %s Succeed！", getGroupid(), i + 1, retry > 0 ? "reconnection" : "init"));
} else {
logger.fine(String.format("ZHubClient[%s] %s Succeed！", getGroupid(), retry > 0 ? "reconnection" : "init"));
}
return true;
} catch (Exception e) {
if (retry == 0 || i == 0) {
logger.log(Level.WARNING, String.format("ZHubClient[%s] %s Failed 初始化失败！", getGroupid(), retry == 0 ? "init" : "reconnection"), e);
try {
Thread.sleep(1000);
} catch (InterruptedException interruptedException) {
interruptedException.printStackTrace();
}
} else {
logger.log(Level.WARNING, String.format("ZHubClient[%s][%s] reconnection Failed！", getGroupid(), i + 1));
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException interruptedException) {
interruptedException.printStackTrace();
}
}
}
}
return false;
}
@Override
public void unsubscribe(String topic) {
send("unsubscribe " + topic);
super.removeEventType(topic);
}
public boolean publish(String topic, Object v) {
return send("publish", topic, toStr(v));
}
public void broadcast(String topic, Object v) {
send("broadcast", topic, toStr(v));
}
// 发送 publish 主题消息，若多次发送的 topic + "-" + value 相同，将会做延时重置
public void delay(String topic, Object v, long millis) {
send("delay", topic, toStr(v), String.valueOf(millis));
}
// 表达式支持：d+[d,H,m,s]
public void delay(String topic, Object v, String delayExpr) {
String endchar = "";
int delay;
if (delayExpr.matches("^\\d+[d,H,m,s]$")) {
endchar = delayExpr.substring(delayExpr.length() - 1);
delay = Integer.parseInt(delayExpr.substring(0, delayExpr.length() - 1));
} else {
if (!delayExpr.matches("^\\d+$")) {
throw new IllegalArgumentException(String.format("ScheduledCycle period config error: [%s]", delayExpr));
}
delay = Integer.parseInt(delayExpr);
if (delay <= 0L) {
throw new IllegalArgumentException(String.format("ScheduledCycle period config error: [%s]", delayExpr));
}
}
switch (endchar) {
case "M":
delay *= (1000 * 60 * 60 * 24 * 30);
break;
case "d":
delay *= (1000 * 60 * 60 * 24);
break;
case "H":
delay *= (1000 * 60 * 60);
break;
case "m":
delay *= (1000 * 60);
break;
case "s":
delay *= 1000;
break;
}
delay(topic, v, delay);
}
@Override
protected String getGroupid() {
return groupid;
}
@Override
protected void subscribe(String topic) {
send("subscribe " + topic); //新增订阅
}
// ================================================== lock ==================================================
private final Map<String, Lock> lockTag = new ConcurrentHashMap<>();
public Lock tryLock(String key, int duration) {
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
Lock lock = new Lock(key, uuid, duration, this);
lockTag.put(uuid, lock);
try {
// c.send("lock", key, uuid, strconv.Itoa(duration))
send("lock", key, uuid, String.valueOf(duration));
synchronized (lock) {
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return lock;
}
// ================================================== timer ==================================================
private final ConcurrentHashMap<String, Timer> timerMap = new ConcurrentHashMap();
class Timer {
String name;
//String expr;
Runnable runnable;
//boolean single;
public String getName() {
return name;
}
public Runnable getRunnable() {
return runnable;
}
public Timer(String name, Runnable runnable) {
this.name = name;
this.runnable = runnable;
}
}
public void timer(String name, Runnable run) {
timerMap.put(name, new Timer(name, run));
send("timer", name);
}
public void reloadTimer() {
send("cmd", "reload-timer");
}
// ================================================== rpc ==================================================
// -- 调用端 --
private static final Map<String, Rpc> rpcMap = new ConcurrentHashMap<>();
private static final Map<String, TypeToken> rpcRetType = new ConcurrentHashMap<>();
// rpc call
public RpcResult<Void> rpc(String topic, Object v) {
return rpc(topic, v, null);
}
// rpc call
public <T, R> RpcResult<R> rpc(String topic, T v, TypeToken<R> typeToken) {
return rpc(topic, v, typeToken, 0);
}
// rpc call
public <T, R> RpcResult<R> rpc(String topic, T v, TypeToken<R> typeToken, long timeout) {
Rpc rpc = new Rpc<>(APP_NAME, UUID.randomUUID().toString().replaceAll("-", ""), topic, v);
String ruk = rpc.getRuk();
rpcMap.put(ruk, rpc);
if (typeToken != null) {
rpcRetType.put(ruk, typeToken);
}
try {
publish(topic, rpc); // send("rpc", topic, toStr(rpc));
synchronized (rpc) {
if (timeout <= 0) {
timeout = 1000 * 15;
}
// call timeout default: 15s
Timers.delay(() -> {
synchronized (rpc) {
Rpc rpc1 = rpcMap.get(ruk);
if (rpc1 == null) {
return;
}
RpcResult rpcResult = rpc.buildResp(505, "请求超时");
rpc.setRpcResult(rpcResult);
logger.warning("rpc timeout: " + gson.toJson(rpc));
rpc.notify();
}
}, timeout);
rpc.wait();
rpcMap.remove(ruk);
}
} catch (InterruptedException e) {
e.printStackTrace();
// call error
RpcResult rpcResult = rpc.buildResp(501, "请求失败");
rpc.setRpcResult(rpcResult);
}
return rpc.getRpcResult();
}
public <T, R> CompletableFuture<RpcResult<R>> rpcAsync(String topic, T v) {
return CompletableFuture.supplyAsync(() -> rpc(topic, v, null));
}
public <T, R> CompletableFuture<RpcResult<R>> rpcAsync(String topic, T v, TypeToken<R> typeToken) {
return CompletableFuture.supplyAsync(() -> rpc(topic, v, typeToken));
}
public <T, R> CompletableFuture<RpcResult<R>> rpcAsync(String topic, T v, long timeout) {
return CompletableFuture.supplyAsync(() -> rpc(topic, v, null, timeout));
}
public <T, R> CompletableFuture<RpcResult<R>> rpcAsync(String topic, T v, TypeToken<R> typeToken, long timeout) {
return CompletableFuture.supplyAsync(() -> rpc(topic, v, typeToken, timeout));
}
// RpcResult: {ruk:xxx-xxxx, retcode:0}
// rpc call back consumer
private void rpcAccept(String value) {
RpcResult resp = gson.fromJson(value, new TypeToken<RpcResult<String>>() {
}.getType());
String ruk = resp.getRuk();
Rpc rpc = rpcMap.remove(ruk);
if (rpc == null) {
return;
}
TypeToken typeToken = rpcRetType.get(ruk);
Object result = resp.getResult();
if (result != null && typeToken != null && !"java.lang.String".equals(typeToken.getType().getTypeName())) {
result = gson.fromJson((String) resp.getResult(), typeToken.getType());
}
resp.setResult(result);
rpc.setRpcResult(resp);
synchronized (rpc) {
rpc.notify();
}
}
// -- 订阅端 --
private final HashSet rpcTopics = new HashSet();
// rpc call consumer
public <T, R> void rpcSubscribe(String topic, TypeToken<T> typeToken, Function<Rpc<T>, RpcResult<R>> fun) {
Consumer<String> consumer = v -> {
Rpc<T> rpc = null;
try {
rpc = gson.fromJson(v, new TypeToken<Rpc<String>>() {
}.getType());
// 参数转换
T paras = gson.fromJson((String) rpc.getValue(), typeToken.getType());
rpc.setValue(paras);
RpcResult result = fun.apply(rpc);
result.setResult(toStr(result.getResult()));
publish(rpc.getBackTopic(), result);
} catch (Exception e) {
logger.log(Level.WARNING, "rpc call consumer error: " + v, e);
publish(rpc.getBackTopic(), rpc.buildError("服务调用失败！"));
}
// back
};
rpcTopics.add(topic);
subscribe(topic, consumer);
}
}