public enum CompressionType {
/**
* deflater
*/
DEFLATER
}
/**
* 分发策略，取值范围为：default、roundRobin、roundRobinWithKey roundRobin:实现负载均衡
的分发策略； default:实现随机的分发策略
* roundRobinWithKey:自定义的分发算法（实现负载均衡以及实现根据key的Hash值取余发送消息）
*
* @author ludingyang
* @version 1
.0
* @since 2021/1/26
*/
public enum DispatchMode {
DEFAULT,
ROUND_ROBIN,
ROUND_ROBIN_WITH_KEY
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EventCenterSendResult {
private String topic;
private String key;
private Event sendEvent;
private long timestamp;
private Integer partition;
}
/**
* 发送结果的封装类
*
* @author ludingyang
* @version 1
.0
* @since 2021/3/17
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class GenericEventCenterSendResult<T> {
private String topic;
private String key;
private T sendEvent;
private long timestamp;
private Integer partition;
}
/**
* Kafka迁移集群类型枚举
*
* @author Zhou Wenpei
* @version 1
.0
* @since 2023/6/2
*/
public enum KafkaClusterEnum {
/**
* 默认的主Kafka集群
*/
PRIMARY(0, "primary"),
/**
* 迁移后的新Kafka集群
*/
SECONDARY(1, "secondary");
@Getter
private final String value;
@Getter
private final Integer type;
(2);
private static final Map<String, KafkaClusterEnum> VALUE_MAP = new HashMap<>
KafkaClusterEnum(Integer type, String value) {
this
.value = value;
this
.type = type;
}
public static KafkaClusterEnum resolve(String value) {
return VALUE_MAP
.get(value);
}
static {
for (KafkaClusterEnum type : values
()) {
VALUE_MAP
.put(type
.getValue
(), type);
}
}
}
/**
* kafka迁移操作枚举
*
* @author Zhou Wenpei
* @version 1
.0
* @since 2023/6/13
*/
public enum KafkaMigrationOperationEnum {
/**
* 切换生产者
*/
REPLACE(0, "replace"),
/**
* 关闭生产者
*/
CLOSE_PRODUCER(1, "closeProducer"),
/**
* 关闭消费者
*/
CLOSE_CONSUMER(2, "closeConsumer");
@Getter
private final String value;
@Getter
private final Integer type;
private static final Map<String, KafkaMigrationOperationEnum> VALUE_MAP = new
HashMap<>(2);
KafkaMigrationOperationEnum(Integer type, String value) {
this
.value = value;
this
.type = type;
}
public static KafkaMigrationOperationEnum resolve(String value) {
return VALUE_MAP
.get(value);
}
static {
for (KafkaMigrationOperationEnum type : values
()) {
VALUE_MAP
.put(type
.getValue
(), type);
}
}
}
public class LogAccess {
private LogAccess
() {
}
public final static LogAccessor LOGGER = new
LogAccessor(LogFactory
.getLog(
Handler.class));
}
/**
* 分区分配策略的枚举类
*
* @author ludingyang
* @version 1
.0
* @since 2021/1/26
*/
public enum PartitionAssignorMode {
/**
* CooperativeSticky和Sticky的结果是一样的，区别在于使用的算法不一样
.
CooperativeSticky是将Sticky一次重平衡的过程分割成多次过程。避免重平衡过长导致系统宕机或者影
响消息消费。
*/
COOPERATIVE_STICKY,
/**
* 从字面意义上看， Sticky 是 “ 粘性的 ” ，可以理解为分配结果是带 “ 粘性的 ” ： 1
. 分区
的分配尽量的均衡 2
. 每一次重分配的结果尽量与上一次分配结果保持一致
* 当这两个目标发生冲突时，优先保证第一个目标。第一个目标是每个分配算法都尽量尝试去完成的，
而第二个目标才真正体现出StickyAssignor 特性的。
*/
STICKY,
/**
* Kafka 默认采用 RangeAssignor 的分配算法 。 RangeAssignor 对每个 Topic 进行独立的
分区分配。对于每一个 Topic ，首先对分区按照分区 ID 进行数值排序，然后订阅这个Topic
* 的消费组的消费者再进行字典排序，之后尽量均衡的将分区分配给消费者。 这里只能是尽量均衡，
因为分区数可能无法被消费者数量整除，那么有一些消费者就会多分配到一些分区
.
*/
RANGE,
/**
* RoundRobinAssignor 的分配策略是将消费组内订阅的所有 Topic 的分区及所有消费者进行排
序后尽量均衡的分配（RangeAssignor 是针对单个 Topic 的分区进行排序分配的）。 如果消费组内，
* 消费者订阅的Topic列表是相同的 （每个消费者都订阅了相同的 Topic ），那么分配结果是尽量
均衡的（消费者之间分配到的分区数的差值不会超过1 ）。 如果订阅的Topic列表是不同的 ，那么分配结果
是不保证 “ 尽量均衡”
* 的
*/
ROUND_ROBIN
}
/**
* 序列化方式枚举类
*
* @author Zhou Wenpei
* @version 1
.0
* @since 2023/9/12
*/
@Getter
public enum SerializeEnum {
/**
* Kryo 序列化，使用KryoSerializeUtil
*/
KRYO(0, "Kryo"),
/**
* Json序列化，使用JsonUtils
*/
JSON(1, "Json");
private final Integer type;
private final String name;
private static final Map<Integer, SerializeEnum> TYPE_MAP = new HashMap<>
(2);
static {
for (SerializeEnum type : values
()) {
TYPE_MAP
.put(type
.getType
(), type);
}
}
public static SerializeEnum resolve(Integer type) {
SerializeEnum serializeEnum = TYPE_MAP
.get(type);
if (Objects
.isNull(serializeEnum)) {
return JSON;
}
return serializeEnum;
}
SerializeEnum(Integer type, String name) {
this
.type = type;
this
.name = name;
}
}
/**
* 获取熔断器状态
*
* @author Zhou Wenpei
* @version 1
.0
* @since 2023/
5/17
*/
public interface CircuitBreakerStatusService {
/**
* 获取对应主题的熔断器状态
*
* @param topicName 主题名，即熔断器名
* @return 状态String
*/
String getCircuitBreakerStatus(String topicName);
}
public interface KafkaMigrationService {
/**
* 切换kafka集群
* @param kafkaMigrationType 切换到新的kafka集群类型
* @return true if success, false otherwise
*/
boolean changeKafkaTemplate(String kafkaMigrationType);
/**
* 关闭kafka生产者
* @param kafkaMigrationType 待关闭kafka生产者集群类型
*/
void closeProducerService(String kafkaMigrationType);
/**
* 关闭kafka消费者
* @param kafkaMigrationType 待关闭kafka消费者集群类型
*/
void closeConsumerService(String kafkaMigrationType);
}
public class AbstractAggregateDomainEvent<A> extends AbstractDomainEvent
implements AggregateDomainEvent {
private A source;
public AbstractAggregateDomainEvent(String type) {
super(type);
}
@Override
public A source
() {
return source;
}
}
@SuperBuilder
@ToString
public abstract class AbstractDomainEvent implements DomainEvent {
protected String id = StringUtils
.generateUUID
();
protected Date createTime = new Date
();
protected String type;
public AbstractDomainEvent
() {
}
public AbstractDomainEvent(String type) {
this
.type = type;
}
@Override
public String id
() {
return id;
}
@Override
public Date occurredOn
() {
return createTime;
}
@Override
public String type
() {
return type;
}
protected String getClassName
() {
return this
.getClass
().getName
();
}
}
public interface AggregateDomainEvent<A> extends DomainEvent {
/**
* 事件发生源 只针对由聚合产生的事件
*/
A source
();
default A getSource
() {
return source
();
}
}
public interface DomainEvent {
/**
* 事件唯一标识
*/
String id
();
/**
* 发生时间
*/
Date occurredOn
();
String type
();
}
/**
* 扩展自 DomainEventPublisher 和 DomainEvent
HandlerRegistry 用于发布和管理领域事件处
理器
*
* @author Fang Jiahao <fangjiahao@tp-link
.com
.cn>
* @since 2020/6/8
*/
public interface DomainEventBus extends DomainEventPublisher,
DomainEvent
HandlerRegistry {
}
/**
* 用于执行领域事件处理器
*
* @author Fang Jiahao <fangjiahao@tp-link
.com
.cn>
* @since 2020/6/8
*/
@Getter
@AllArgsConstructor
public class DomainEventExecutor {
private DomainEventSubscriber subscriber;
private Executor executor;
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass
() != o
.getClass
()) {
return false;
}
DomainEventExecutor that = (DomainEventExecutor) o;
return subscriber
.equals(that
.subscriber);
}
@Override
public int hashCode
() {
return Objects
.hash(subscriber);
}
public DomainEventExecutor(DomainEventSubscriber subscriber) {
this
.subscriber = subscriber;
}
}
/**
* 用于处理领域事件
*
* @author Fang Jiahao <fangjiahao@tp-link
.com
.cn>
* @since 2020/6/8
*/
public interface DomainEvent
Handler<D> {
}
void handleEvent(final D aDomainEvent);
/**
* 用于注册 DomainEvent
Handler
*
* @author Fang Jiahao <fangjiahao@tp-link
.com
.cn>
* @since 2020/6/8
*/
public interface DomainEvent
HandlerRegistry {
/**
* 废弃的异步注册方法
*
* @param dClass
dClass
* @param subscriber 注册类
* @deprecated use {@link # register(Class<D> dClass,
DomainEventSubscriber<D> subscriber, ExecutorService
* executorService)} instead
.
*/
@Deprecated
<D> void register(Class<D> dClass, DomainEventSubscriber<D> subscriber);
/**
* 同步调用注册接口
*
* @param dClass
dClass
* @param subscriber 注册类
* @param <D>
类
*/
<D> void registerSync(Class<D> dClass, DomainEventSubscriber<D> subscriber);
/**
* 异步调用注册接口
*
* @param dClass
* @param subscriber
* @param <D>
dClass
注册类
类
* @param executorService 业务线程池
*/
<D> void register(Class<D> dClass, DomainEventSubscriber<D> subscriber,
ExecutorService executorService);
<D> void unRegister(DomainEventSubscriber<D> subscriber);
}
/**
* 回调函数
*
* @author Sun Xiaoyu
* @version 1
.0
* @since 2020-07-07
*/
public interface DomainEventPost
Handler<D extends DomainEvent> {
void postEventSuccess
();
}
void postEventFailed
();
/**
* 用于发布领域事件
*
* @author Fang Jiahao <fangjiahao@tp-link
.com
.cn>
* @since 2020/6/8
*/
public interface DomainEventPublisher {
void publish(DomainEvent domainEvent);
void publishSync(DomainEvent domainEvent);
default void publishAll(List<DomainEvent> domainEvents) {
for (DomainEvent aDomainEvent : domainEvents) {
publish(aDomainEvent);
}
}
}
/**
* 用于判断是否接受领域事件 处理领域事件
*
* @author Fang Jiahao <fangjiahao@tp-link
.com
.cn>
* @since 2020/6/4
*/
public interface DomainEventSubscriber<D> {
default boolean accept(D event) {
return true;
}
void handleEvent(final D event);
default void onEventFailed(D event) {
}
}
}
default void onEventSuccess(D event) {
@Retention(RetentionPolicy
.RUNTIME)
@Target(ElementType
.METHOD)
public @interface HandleEvent {
}
Class<? extends DomainEvent>[] value
();
public class DuplicateGroupIdException extends RuntimeException {
public DuplicateGroupIdException
() {
super
();
}
public DuplicateGroupIdException(String message) {
super(message);
}
}
public DuplicateGroupIdException(String message, Throwable cause) {
super(message, cause);
}
public DuplicateGroupIdException(Throwable cause) {
super(cause);
}
public class JsonUtils {
/**
* can reuse, share globally
*/
private static ObjectMapper mapper = new ObjectMapper
();
public static ObjectMapper getMapper
() {
return mapper;
}
public static void setMapper(ObjectMapper mapper) {
JsonUtils
.mapper = mapper;
}
private static final Logger logger =
LoggerFactory
.getLogger(JsonUtils
.class);
public static <T> T readFile(File file, Class<T> tClass) {
try {
return mapper
.readValue(file, tClass);
} catch (IOException e) {
logger
.warn("Parse json message exception
.", e);
return null;
}
}
public static <T> T readInputStream(InputStream inputStream, Class<T> tClass)
{
try {
return mapper
.readValue(inputStream, tClass);
} catch (IOException e) {
logger
.warn("Parse json message exception
.", e);
return null;
}
}
public static String bean2Json(Object object) {
try {
return mapper
.writeValueAsString(object);
} catch (JsonProcessingException e) {
logger
.warn("fail to transfer bean to Json", e);
return null;
}
}
public static byte[] bean2Bytes(Object object) {
try {
return mapper
.writeValueAsBytes(object);
} catch (JsonProcessingException e) {
logger
.warn("fail to transfer bean to bytes", e);
return null;
}
}
public static <T> T json2bean(String json, Class<T> clazz) {
try {
return mapper
.readValue(json, clazz);
} catch (IOException e) {
logger
.debug("Parse json message exception
. jsonString:{}, class:{}",
json, clazz, e);
return null;
}
}
public static <T> T map2Bean(Map map, Class<T> tClass) {
return mapper
.convertValue(map, tClass);
}
public static <T> List<? super T> json2list(String json, Class<T> tClass) {
JavaType type = getCollectionType(List
.class, tClass);
try {
return mapper
.readValue(json, type);
} catch (IOException e) {
logger
.warn("fail to transfer json to list
.", e);
return null;
}
}
public static Map<String, Object> json2Map(String json) {
TypeReference<HashMap<String, Object>> typeRef = new
TypeReference<HashMap<String, Object>>
() {
};
try {
return mapper
.readValue(json, typeRef);
} catch (IOException e) {
logger
.warn("fail to transfer json to map
.", e);
return null;
}
}
public static Map<String, Object> json2MapWithoutLog(String json) {
TypeReference<HashMap<String, Object>> typeRef = new
TypeReference<HashMap<String, Object>>
() {
};
try {
return mapper
.readValue(json, typeRef);
} catch (IOException e) {
return null;
}
}
public static JavaType getCollectionType(Class<?> collectionClass, Class<?>
elementClasses) {
return mapper
.getTypeFactory
().constructParametricType(collectionClass,
elementClasses);
}
}
/**
* Kryo序列化、反序列化类
*
* @author Zhou Wenpei
* @version 1
.0
* @since 2023/8/11
*/
@Slf4j
public class KryoSerializeUtils {
/**
* 线上大都小于10K，由于粒度问题，无法查看细致的大小，暂定初始大小为
5K
*/
private static final int KRYO_BUFFER_SIZE =
5 * 1024;
private KryoSerializeUtils
() {
}
/**
* 线程不安全，通过ThreadLocal实现
*/
private static final ThreadLocal<Kryo> KRYOS = ThreadLocal
.withInitial(
() ->
{
// 在此处配置kryo对象
Kryo kryo = new Kryo
();
kryo
.setRegistrationRequired(false);
return kryo;
});
/**
* Kryo 序列化，序列化失败将返回空字节数组
*/
public static byte[] bean2ByteArray(Object object) {
try (Output output = new Output(KRYO_BUFFER_SIZE, -1)) {
Kryo kryo = KRYOS
.get
();
kryo
.writeObject(output, object);
return output
.toBytes
();
} catch (Exception e) {
log
.warn("kryo serial object failed, exception :{}", e);
return new byte[0];
}
}
/**
* Kryo 反序列化，反序列化失败将返回空对象
*/
public static <T> T byteArray2Bean(byte[] source, Class<T> destinationClass)
{
Kryo kryo = KRYOS
.get
();
try (Input input = new Input(source)) {
return kryo
.readObject(input, destinationClass);
} catch (Exception e) {
log
.warn("kryo deserialize object failed, exception :{}", e);
}
return null;
}
public static void clearKryo
() {
KRYOS
.remove
();
}
}
public class StringUtils {
private StringUtils
() {
}
public static String generateUUID
() {
return UUID
.randomUUID
().toString
().replace("-", "");
}
}
@Getter
@NoArgsConstructor
@SuperBuilder
@AllArgsConstructor
public abstract class BaseEvent<T> {
protected String filterKey;
protected long timeStamp;
protected T message;
}
/**
* 事件中心用于传递事件的类，eventStr为从消息中间件拿到的具体事件，反序列化工作由业务层完成
*
* @author ludingyang
* @version 1
.0
* @since 2020/6/29
.
*/
@Getter
@NoArgsConstructor
@SuperBuilder
public final class Event extends BaseEvent<String> {
public Event(String filterKey, String message) {
this
.filterKey = filterKey;
this
.message = message;
}
@Override
public String toString
() {
return JsonUtils
.bean2Json(this);
}
public void setTimeStamp(long timeStamp) {
this
.timeStamp = timeStamp;
}
public static Event toBean(String string) {
return JsonUtils
.json2bean(string, Event
.class);
}
}
/**
* Event Center组件对外提供的方法
*
* @author ludingyang
* @version 1
.0
* @since 2020/7/30
.
*/
public interface EventCenter {
/**
* 获取到topic的partition数量 该接口只能获取到使用EventCenter register的topic分区数
量
*
* @param topic topic名
* @return partition数量，如果是不存在的topic则为0
*/
default Integer getPartitions(String topic) {
return 0;
}
/**
* 发送事件,会发送到任意分区上
*
* @param topic 事件主题
* @param event 事件消息主体
*/
default void send(@Nonnull String topic, @Nonnull Event event) {
}
/**
* 发送事件，包含了回调方法
*
* @param topic 事件主题
* @param event 事件消息主体
* @param eventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功后的回调方
法); onFailure(发送失败后的回调方法)
*/
default void send(@Nonnull String topic, @Nonnull Event event, EventFuture
eventFuture) {
}
/**
* 发送事件,相同key值的消息会发送到同一个分区上
*
* @param topic 事件主题
* @param key 发送消息的key值，用于将相同key值的消息发送到同一分区中
* @param event 事件消息主体
*/
default void send(@Nonnull String topic, String key, @Nonnull Event event) {
}
/**
* 发送事件,相同key值的消息会发送到同一个分区上
*
* @param topic 事件主题
* @param key 发送消息的key值，用于将相同key值的消息发送到同一分区中
* @param event 事件消息主体
* @param eventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功后的回调方
法); onFailure(发送失败后的回调方法)
*/
default void send(@Nonnull String topic, String key, @Nonnull Event event,
EventFuture eventFuture) {
}
/**
* 发送事件,消息会发送到分区partition上
*
* @param topic 事件主题
* @param partition 分区
* @param event 事件消息主体
*/
default void send(@Nonnull String topic, @Nonnull Integer partition, @Nonnull
Event event) {
}
/**
* 发送事件,消息会发送到分区partition上
*
* @param topic 事件主题
* @param partition 分区
* @param event 事件消息主体
* @param eventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功后的回调方
法); onFailure(发送失败后的回调方法)
*/
default void send(@Nonnull String topic, @Nonnull Integer partition, @Nonnull
Event event,
EventFuture eventFuture) {
}
/**
* 发送事件,会发送到任意分区上
*
* @param topic 事件主题
* @param event 事件消息主体，如果serializeEnum采用Kryo序列化，event类型需要为
EventV2；如果采用Json序列化，event类型为Event
* @param serializeEnum 采用的序列化方式
*/
default void send(@Nonnull String topic, @Nonnull BaseEvent event, @Nonnull
SerializeEnum serializeEnum) {
}
/**
* 发送事件，包含了回调方法
*
* @param topic 事件主题
* @param event 事件消息主体，如果serializeEnum采用Kryo序列化，event类型需要
为EventV2；如果采用Json序列化，event类型为Event
* @param eventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功后的回调方
法); onFailure(发送失败后的回调方法)
* @param serializeEnum 采用的序列化方式
*/
default void send(@Nonnull String topic, @Nonnull BaseEvent event,
GenericEventFuture eventFuture,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 发送事件,相同key值的消息会发送到同一个分区上
*
* @param topic 事件主题
* @param key 发送消息的key值，用于将相同key值的消息发送到同一分区中
* @param event 事件消息主体，如果serializeEnum采用Kryo序列化，event类型需要为
EventV2；如果采用Json序列化，event类型为Event
* @param serializeEnum 采用的序列化方式
*/
default void send(@Nonnull String topic, String key, @Nonnull BaseEvent
event,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 发送事件,相同key值的消息会发送到同一个分区上
*
* @param topic 事件主题
* @param key 发送消息的key值，用于将相同key值的消息发送到同一分区中
* @param event 事件消息主体，如果serializeEnum采用Kryo序列化，event类型需要
为EventV2；如果采用Json序列化，event类型为Event
* @param eventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功后的回调方
法); onFailure(发送失败后的回调方法)
* @param serializeEnum 采用的序列化方式
*/
default void send(@Nonnull String topic, String key, @Nonnull BaseEvent
event, GenericEventFuture eventFuture,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 发送事件,消息会发送到分区partition上
*
* @param topic 事件主题
* @param partition 分区
* @param event 事件消息主体，如果serializeEnum采用Kryo序列化，event类型需要为
EventV2；如果采用Json序列化，event类型为Event
* @param serializeEnum 采用的序列化方式
*/
default void send(@Nonnull String topic, @Nonnull Integer partition, @Nonnull
BaseEvent event,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 发送事件,消息会发送到分区partition上
*
* @param topic 事件主题
* @param partition 分区
* @param event 事件消息主体，如果serializeEnum采用Kryo序列化，event类型需要
为EventV2；如果采用Json序列化，event类型为Event
* @param eventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功后的回调方
法); onFailure(发送失败后的回调方法)
* @param serializeEnum 采用的序列化方式
*/
default void send(@Nonnull String topic, @Nonnull Integer partition, @Nonnull
BaseEvent event,
GenericEventFuture eventFuture, @Nonnull SerializeEnum serializeEnum) {
}
/**
* 注册处理广播事件的
handler（默认分区分配策略为COOPERATIVE_STICKY）
*
* @param topic 主题
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
*/
default void registerBroadcast(@Nonnull String topic, @Nonnull Event
Handler
handler,
@Nonnull ExecutorService executorService) {
}
/**
* 注册处理广播事件的
handler
*
* @param topic 主题
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param partitionAssignorMode 分区分配策略
*/
default void registerBroadcast(@Nonnull String topic, @Nonnull Event
Handler
handler,
@Nonnull ExecutorService executorService,
PartitionAssignorMode partitionAssignorMode) {
}
/**
* 注册处理单播事件的
handler（默认分区分配策略为COOPERATIVE_STICKY）
*
* @param topic 主题
* @param groupId 消费者组Id
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
*/
default void registerUnicast(@Nonnull String topic, @Nonnull String groupId,
@Nonnull Event
Handler handler,
@Nonnull ExecutorService executorService) {
}
/**
* 注册处理单播事件的
handler
*
* @param topic 主题
* @param groupId 消费者组Id
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param partitionAssignorMode 分区分配策略
*/
default void registerUnicast(@Nonnull String topic, @Nonnull String groupId,
@Nonnull Event
Handler handler,
@Nonnull ExecutorService executorService, PartitionAssignorMode
partitionAssignorMode) {
}
/**
* 注册处理广播事件的
handler(不传线程池)
*
* @param topic 主题
* @param
handler 事件处理类
* @param partitionAssignorMode 分区分配策略
*/
default void registerBroadcastWithoutThreadPool(@Nonnull String topic,
@Nonnull Event
Handler handler,
PartitionAssignorMode partitionAssignorMode) {
}
/**
* 注册处理单播事件的
handler(不传线程池)
*
* @param topic 主题
* @param groupId 消费者组
* @param
handler 事件处理类
* @param partitionAssignorMode 分区分配策略
*/
default void registerUnicastWithoutThreadPool(@Nonnull String topic, @Nonnull
String groupId,
@Nonnull Event
Handler handler,
PartitionAssignorMode partitionAssignorMode) {
}
/**
* 解注册一个主题下的
handler
*
* @param topic 主题
* @param
handler 事件处理类
*/
default void unregister(@Nonnull String topic, @Nonnull Event
Handler handler)
{
}
/**
* 发送事件,会发送到任意分区上
*
* @param topic 事件主题
* @param event 事件消息主体
*/
default <T> void sendGenerically(@Nonnull String topic, @Nonnull T event) {
}
/**
* 发送事件，包含了回调方法
*
* @param topic 事件主题
* @param event 事件消息主体
* @param genericEventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功
后的回调方法); onFailure(发送失败后的回调方法)
*/
default <T> void sendGenerically(@Nonnull String topic, @Nonnull T event,
GenericEventFuture<T> genericEventFuture) {
}
/**
* 发送事件,相同key值的消息会发送到同一个分区上
*
* @param topic 事件主题
* @param key 发送消息的key值，用于将相同key值的消息发送到同一分区中
* @param event 事件消息主体
*/
default <T> void sendGenerically(@Nonnull String topic, String key, @Nonnull
T event) {
}
/**
* 发送事件,相同key值的消息会发送到同一个分区上
*
* @param topic 事件主题
* @param key 发送消息的key值，用于将相同key值的消息发送到同一分区中
* @param event 事件消息主体
* @param genericEventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功
后的回调方法); onFailure(发送失败后的回调方法)
*/
default <T> void sendGenerically(@Nonnull String topic, String key, @Nonnull
T event,
GenericEventFuture<T> genericEventFuture) {
}
/**
* 发送事件,消息会发送到分区partition上
*
* @param topic 事件主题
* @param partition 分区
* @param event 事件消息主体
*/
default <T> void sendGenerically(@Nonnull String topic, @Nonnull Integer
partition, @Nonnull T event) {
}
/**
* 发送事件,消息会发送到分区partition上
*
* @param topic 事件主题
* @param partition 分区
* @param event 事件消息主体
* @param genericEventFuture 包含发送成功或失败后执行的回调方法：onSuccess(发送成功
后的回调方法); onFailure(发送失败后的回调方法)
*/
default <T> void sendGenerically(@Nonnull String topic, @Nonnull Integer
partition, @Nonnull T event,
GenericEventFuture<T> genericEventFuture) {
}
/**
* 注册处理广播事件的
handler（默认分区分配策略为COOPERATIVE_STICKY）
*
* @param topic 主题
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param clazz 定义类
*/
default <T> void registerBroadcastGenerically(@Nonnull String topic, @Nonnull
GenericEvent
Handler<T>
handler,
@Nonnull ExecutorService executorService, @NonNull Class<T> clazz) {
}
/**
* 注册处理广播事件的
handler
*
* @param topic 主题
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param partitionAssignorMode 分区分配策略
* @param clazz 定义类
*/
default <T> void registerBroadcastGenerically(@Nonnull String topic, @Nonnull
GenericEvent
Handler<T>
handler,
@Nonnull ExecutorService executorService,
PartitionAssignorMode partitionAssignorMode, @NonNull Class<T> clazz) {
}
/**
* 注册处理单播事件的
handler（默认分区分配策略为COOPERATIVE_STICKY）
*
* @param topic 主题
* @param groupId 消费者组Id
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param clazz 定义类
*/
default <T> void registerUnicastGenerically(@Nonnull String topic, @Nonnull
String groupId,
@Nonnull GenericEvent
Handler<T>
handler,
@Nonnull ExecutorService executorService, @NonNull Class<T> clazz) {
}
/**
* 注册处理单播事件的
handler
*
* @param topic 主题
* @param groupId 消费者组Id
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param partitionAssignorMode 分区分配策略
* @param clazz 定义类
*/
default <T> void registerUnicastGenerically(@Nonnull String topic, @Nonnull
String groupId,
@Nonnull GenericEvent
Handler<T>
handler,
@Nonnull ExecutorService executorService, PartitionAssignorMode
partitionAssignorMode,
@NonNull Class<T> clazz) {
}
/**
* 注册处理广播事件的
handler(不传线程池)
*
* @param topic 主题
* @param
handler 事件处理类
* @param partitionAssignorMode 分区分配策略
* @param clazz 定义类
*/
default <T> void registerBroadcastWithoutThreadPoolGenerically(@Nonnull
String topic,
@Nonnull GenericEvent
Handler<T>
handler,
PartitionAssignorMode partitionAssignorMode, @NonNull Class<T> clazz) {
}
/**
* 注册处理单播事件的
handler(不传线程池)
*
* @param topic 主题
* @param groupId 消费者组
* @param
handler 事件处理类
* @param partitionAssignorMode 分区分配策略
* @param clazz 定义类
*/
default <T> void registerUnicastWithoutThreadPoolGenerically(@Nonnull String
topic, @Nonnull String groupId,
@Nonnull GenericEvent
Handler<T>
handler,
PartitionAssignorMode partitionAssignorMode, @NonNull Class<T> clazz) {
}
/**
* 解注册一个主题下的
handler
*
* @param topic 主题
* @param
handler 事件处理类
*/
default <T> void unregisterGenerically(@Nonnull String topic, @Nonnull
GenericEvent
Handler<T>
handler) {
}
/**
* 在不销毁executorService的场景下，解注册单个topic
* @param topic 主题
* @param
handler 事件处理类
* @param isDestroyExecutorService 是否需要销毁线程池
*/
default <T> void unregisterGenerically(@Nonnull String topic, @Nonnull
GenericEvent
Handler<T>
handler,
boolean isDestroyExecutorService) {
}
/**
* 在不销毁executorService的场景下，解注册单个topic
* @param topic 主题
* @param event
Handler 事件处理类
* @param isDestroyExecutorService 是否需要销毁线程池
*/
default void unregister(@Nonnull String topic, @Nonnull Event
Handler
event
Handler,
boolean isDestroyExecutorService) {
}
/**
* 注册处理广播事件的
handler（默认分区分配策略为COOPERATIVE_STICKY）
*
* @param topic 主题
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param serializeEnum 采用的序列化方式
*/
default void registerBroadcast(@Nonnull String topic, @Nonnull
GenericEvent
Handler handler,
@Nonnull ExecutorService executorService, @Nonnull SerializeEnum
serializeEnum) {
}
/**
* 注册处理广播事件的
handler
*
* @param topic 主题
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param partitionAssignorMode 分区分配策略
* @param serializeEnum 采用的序列化方式
*/
default void registerBroadcast(@Nonnull String topic, @Nonnull
GenericEvent
Handler handler,
@Nonnull ExecutorService executorService, PartitionAssignorMode
partitionAssignorMode,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 注册处理单播事件的
handler（默认分区分配策略为COOPERATIVE_STICKY）
*
* @param topic 主题
* @param groupId 消费者组Id
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param serializeEnum 采用的序列化方式
*/
default void registerUnicast(@Nonnull String topic, @Nonnull String groupId,
@Nonnull GenericEvent
Handler handler, @Nonnull ExecutorService
executorService,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 注册处理单播事件的
handler
*
* @param topic 主题
* @param groupId 消费者组Id
* @param
handler 事件处理类
* @param executorService 上层传递的处理业务的线程池
* @param partitionAssignorMode 分区分配策略
* @param serializeEnum 采用的序列化方式
*/
default void registerUnicast(@Nonnull String topic, @Nonnull String groupId,
@Nonnull GenericEvent
Handler handler,
@Nonnull ExecutorService executorService, PartitionAssignorMode
partitionAssignorMode,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 注册处理广播事件的
handler(不传线程池)
*
* @param topic 主题
* @param
handler 事件处理类
* @param partitionAssignorMode 分区分配策略
* @param serializeEnum 采用的序列化方式
*/
default void registerBroadcastWithoutThreadPool(@Nonnull String topic,
@Nonnull GenericEvent
Handler handler, PartitionAssignorMode
partitionAssignorMode,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 注册处理单播事件的
handler(不传线程池)
*
* @param topic 主题
* @param groupId 消费者组
* @param
handler 事件处理类
* @param partitionAssignorMode 分区分配策略
* @param serializeEnum 采用的序列化方式
*/
default void registerUnicastWithoutThreadPool(@Nonnull String topic, @Nonnull
String groupId,
@Nonnull GenericEvent
Handler handler, PartitionAssignorMode
partitionAssignorMode,
@Nonnull SerializeEnum serializeEnum) {
}
/**
* 解注册所有的topic
*/
default void unregisterAllTopics
() {
}
/**
* 销毁EventCenter时释放资源
*/
@PreDestroy
default void destroy
() {
}
}
public interface EventFuture {
/**
* 发送成功后的回调函数
*
* @param eventCenterSendResult 发送结果
*/
void onSuccess(EventCenterSendResult eventCenterSendResult);
/**
* 发送失败后的回调函数
*
* @param throwable 发送异常
*/
void onFailure(Throwable throwable);
}
/**
* Event Center处理监听到的Event事件，具体业务实现在各个模块进行
*
* @author ludingyang
* @version 1
.0
* @since 2020/6/29
.
*/
public interface Event
Handler extends
Handler {
/**
* 业务处理的方法
*
* @param event 传递的消息封装类
*/
void handleEvent(Event event);
}
@Getter
@NoArgsConstructor
@SuperBuilder
@Slf4j
@ToString
public final class EventV2<T> extends BaseEvent<T> {
public EventV2(String filterKey, T message) {
this
.filterKey = filterKey;
this
.message = message;
}
public void setTimeStamp(long timeStamp) {
this
.timeStamp = timeStamp;
}
}
public static EventV2 toBean(byte[] bytes) {
return KryoSerializeUtils
.byteArray2Bean(bytes, EventV2
.class);
}
public byte[] kryoSerialize
() {
return KryoSerializeUtils
.bean2ByteArray(this);
}
/**
* Producer可配置的回调函数（泛型接口 / EventV2接口）
*
* @author ludingyang
* @version 1
.0
* @since 2021/3/17
*/
public interface GenericEventFuture<T> {
/**
* 发送成功后的回调函数
*
* @param genericEventCenterSendResult 发送结果
*/
void onSuccess(GenericEventCenterSendResult<T>
genericEventCenterSendResult);
/**
* 发送失败后的回调函数
*
* @param throwable 发送异常
*/
void onFailure(Throwable throwable);
}
/**
* Event Center处理监听到的事件，具体业务实现在各个模块进行（泛型接口）
*
* @author ludingyang
* @version 1
.0
* @since 2020/6/29
.
*/
public interface GenericEvent
Handler<T> extends
Handler {
/**
* 业务处理的方法
*
* @param event 传递的消息封装类
*/
void handleEvent(T event);
}
public interface
Handler {
/**
* 重平衡之前可以调用执行 可以做一些简单的操作，不建议执行耗时操作，不然会拉长重平衡时间 对
于eager rebalance：STICKY，RANGE，ROUND_ROBIN；每次进行重平衡时都会触发一次。
* 对于cooperative rebalance：COOPERATIVE_STICKY；只有在consumer被分配的
partitions被主动销毁或者consumer准备离开consumer group时才会触发一次
*/
default void doBeforeRebalance
() {
LogAccess
.LOGGER
.info("start to process rebalance!");
}
/**
* 重平衡之后可以调用执行 可以做一些简单的操作，不建议执行耗时操作，不然会拉长重平衡时间 每
次重平衡结束后会触发一次
*/
default void doAfterRebalance
() {
LogAccess
.LOGGER
.info("ending rebalance!");
}
以上为eventcenter-api的全部代码，后续的开发将基于这些接口，请熟悉并
了解每项功能
本文围绕Android的Handler展开，介绍其是线程切换工具类，可实现子线程到主线程的UI刷新。还探讨了线程中Handler和Looper的数量、主线程与子线程使用Handler的区别、内存泄漏原因、消息阻塞实现等，同时提及优化机制和线程安全保证等内容。
扫一扫
1236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
