repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/package-info.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/package-info.java | package cn.bixin.sona.server.room.strategy; | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/stream/DefaultStrategy.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/stream/DefaultStrategy.java | package cn.bixin.sona.server.room.strategy.stream;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.request.callback.*;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import cn.bixin.sona.server.room.domain.enums.ProductEnum;
import cn.bixin.sona.server.room.domain.enums.PullModeEnum;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.generator.StreamIdGenerator;
import cn.bixin.sona.server.room.service.*;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
@Component("defaultStrategy")
public class DefaultStrategy implements StreamOperation {
private static final Logger log = LoggerFactory.getLogger(DefaultStrategy.class);
@Resource
protected StreamService streamService;
@Resource
protected RoomService roomService;
@Resource
protected StreamIdGenerator streamIdGenerator;
@Resource
protected ProductConfigService productConfigService;
@Override
public void handleCreate(CreateStreamCallback callback) {
}
@Override
public void handleClose(CloseStreamCallback callback) {
}
@Override
public void handleReplay(CreateReplayCallback callback) {
String streamId = callback.getStreamId();
streamService.replayStreamCallback(callback);
StreamSupplierEnum streamSupplier = StreamSupplierEnum.getByCode(callback.getSource());
if (streamSupplier == null) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
StreamContext streamContext = StreamContext.convert(streamId);
if (streamContext == null) {
boolean handleMixReplay = streamService.handleMixReplay(callback);
if (!handleMixReplay) {
log.error("handleCreate streamContext is null, callback={}", JSON.toJSONString(callback));
}
}
}
@Override
public void handleAdd(StreamContext context) {
}
@Override
public void handleClose(StreamContext context) {
}
protected boolean isPullMixedMode(String productCode) {
ProductConfig productConfig = productConfigService.getConfigInfoByCode(productCode);
if (productConfig == null) {
return false;
}
return productConfig.getPullMode().equals(PullModeEnum.MIXED.name());
}
protected List<String> getExistStreamList(String result, List<String> mixStreams) {
List<String> nonExistSteamList = getNotExistSteamList(result);
if (CollectionUtils.isEmpty(nonExistSteamList) || CollectionUtils.isEmpty(mixStreams)) {
return mixStreams;
}
mixStreams.removeAll(nonExistSteamList);
log.info("getExistStreamList stream:{}", mixStreams);
return mixStreams;
}
protected List<String> getNotExistSteamList(String result) {
return Collections.emptyList();
}
@Override
public void handleMixStart(MixStreamStartCallback callback) {
RoomDTO roomDTO = roomService.getRoomByRoomId(Long.valueOf(callback.getBizRoomId()));
if (roomDTO == null) {
log.error("handleMixStart error, roomDTO is null, callback={}", JSON.toJSONString(callback));
return;
}
streamService.addMixStream(callback, roomDTO.getRoomId());
}
@Override
public void handleMixEnd(MixStreamEndCallback callback) {
RoomDTO roomDTO = roomService.getRoomByRoomId(Long.valueOf(callback.getBizRoomId()));
if (roomDTO == null) {
log.error("handleMixStart error, roomDTO is null, callback={}", JSON.toJSONString(callback));
return;
}
streamService.stopMixStream(callback);
}
protected boolean isMixed(RoomConfig roomConfig, ProductEnum platform) {
log.info("isMixed roomConfig={}", JSON.toJSONString(roomConfig));
if (roomConfig == null) {
return isPullMixedMode(platform.name());
} else {
return roomConfig.getPullMode().equals(PullModeEnum.MIXED.name());
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/stream/TencentStrategy.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/stream/TencentStrategy.java | package cn.bixin.sona.server.room.strategy.stream;
import cn.bixin.sona.request.callback.CloseStreamCallback;
import cn.bixin.sona.request.callback.CreateStreamCallback;
import cn.bixin.sona.server.room.domain.enums.ProductEnum;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.generator.StreamIdGenerator;
import cn.bixin.sona.server.room.service.ProductConfigService;
import cn.bixin.sona.server.room.service.StreamService;
import cn.bixin.sona.server.room.service.TencentService;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
@Component("tencentStrategy")
public class TencentStrategy extends DefaultStrategy {
private static final Logger log = LoggerFactory.getLogger(TencentStrategy.class);
@Resource
private StreamService streamService;
@Resource
private StreamIdGenerator streamIdGenerator;
@Resource
private ProductConfigService productConfigService;
@Resource
private TencentService tencentService;
@Value("${tencent.prefix.url}")
private String tencentPrefixUrl;
@Value("${tencent.rtmp.url}")
private String tencentRtmpUrl;
@Override
public void handleCreate(CreateStreamCallback callback) {
String streamId = callback.getStreamId();
ProductEnum platform = streamIdGenerator.getPlatform(streamId);
if (platform == null) {
return;
}
try {
StreamContext streamContext = StreamContext.convert(streamId);
if (streamContext == null) {
log.error("tencent handleCreate streamContext is null, callback={}", JSON.toJSONString(callback));
return;
}
String rtmpUrl = tencentRtmpUrl + streamId;
String hlsUrl = tencentPrefixUrl + streamId + ".m3u8";
String hdlUrl = tencentPrefixUrl + streamId + ".flv";
String picUrl = "/pic";
callback.setRoomId(streamContext.getRoomId());
callback.setStreamId(streamId);
callback.setSource(2);
callback.setRtmpUrls(Lists.newArrayList(rtmpUrl));
callback.setHlsUrls(Lists.newArrayList(hlsUrl));
callback.setHdlUrls(Lists.newArrayList(hdlUrl));
callback.setPicUrls(Lists.newArrayList(picUrl));
callback.setCreateTime(new Date());
callback.setUid(streamContext.getUid());
boolean result = streamService.createStreamCallback(callback);
log.info("tencent handleCreate result:{}, streamId={}", result, streamId);
long roomId = streamContext.getRoomId();
if (isMixed(productConfigService.getRoomConfig(roomId), platform)) {
tencentService.mix(roomId);
}
} catch (Exception e) {
log.error("tencent handleCreate error. streamId:{}", streamId, e);
}
}
@Override
public void handleClose(CloseStreamCallback callback) {
String streamId = callback.getStreamId();
ProductEnum platform = streamIdGenerator.getPlatform(streamId);
if (platform == null) {
return;
}
try {
StreamContext streamContext = StreamContext.convert(streamId);
if (streamContext == null) {
log.error("tencent handleClose streamContext is null, callback={}", JSON.toJSONString(callback));
return;
}
callback.setRoomId(String.valueOf(streamContext.getRoomId()));
streamService.closeStreamCallback(callback);
} catch (Exception e) {
log.error("tencent handleClose error. streamId:{}", streamId, e);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/stream/ZegoStrategy.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/strategy/stream/ZegoStrategy.java | package cn.bixin.sona.server.room.strategy.stream;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.request.callback.CloseStreamCallback;
import cn.bixin.sona.request.callback.CreateStreamCallback;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.Stream;
import cn.bixin.sona.server.room.domain.enums.ProductEnum;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.generator.StreamIdGenerator;
import cn.bixin.sona.server.room.service.ProductConfigService;
import cn.bixin.sona.server.room.service.RoomService;
import cn.bixin.sona.server.room.service.StreamService;
import cn.bixin.sona.server.room.service.ZegoService;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component("zegoStrategy")
public class ZegoStrategy extends DefaultStrategy {
private static final Logger log = LoggerFactory.getLogger(ZegoStrategy.class);
@Resource
private ZegoService zegoService;
@Resource
private StreamService streamService;
@Resource
private StreamIdGenerator streamIdGenerator;
@Resource
private ProductConfigService productConfigService;
@Resource
private RoomService roomService;
@Override
public void handleCreate(CreateStreamCallback callback) {
String streamId = callback.getStreamId();
ProductEnum platform = streamIdGenerator.getPlatform(streamId);
if (platform == null) {
return;
}
try {
StreamContext streamContext = StreamContext.convert(streamId);
if (streamContext == null) {
log.error("zego handleCreate streamContext is null, callback={}", JSON.toJSONString(callback));
return;
}
callback.setUid(streamContext.getUid());
boolean result = streamService.createStreamCallback(callback);
log.info("zego handleCreate result:{}, streamId={}", result, streamId);
long roomId = streamContext.getRoomId();
if (isMixed(productConfigService.getRoomConfig(roomId), platform)) {
zegoService.mix(roomId);
}
} catch (Exception e) {
log.error("zego handleCreate error. stream error. streamId:{}", streamId, e);
}
}
@Override
public void handleClose(CloseStreamCallback callback) {
String streamId = callback.getStreamId();
ProductEnum platform = streamIdGenerator.getPlatform(streamId);
if (platform == null) {
log.warn("zego handleClose platform null. streamId:{}", streamId);
return;
}
Stream streamInfo = streamService.getStreamByStreamId(streamId);
if (streamInfo == null) {
log.error("zego handleClose stream empty. streamId:{}", streamId);
return;
}
boolean result = streamService.closeStreamCallback(callback);
if (!result) {
log.info("zego handlecloseStream, stream:{} already close", streamId);
}
}
@Override
public void handleAdd(StreamContext context) {
if (context == null) {
log.error("ZegoStrategy.handleAdd, context is null");
throw new YppRunTimeException(ExceptionCode.EMPTY_PARAM);
}
String streamId = context.getStreamId();
long roomId = context.getRoomId();
RoomDTO roomDTO = roomService.getRoomByRoomId(roomId);
if (roomDTO == null) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
boolean result = streamService.addStream(context);
log.info("zegoStrategy handleAdd.addStream, stream:{}, result={}", streamId, result);
}
@Override
public void handleClose(StreamContext context) {
if (context == null) {
throw new YppRunTimeException(ExceptionCode.EMPTY_PARAM);
}
String streamId = context.getStreamId();
Stream streamInfo = streamService.getStreamByStreamId(streamId);
if (streamInfo == null || streamInfo.getStatus() == 0) {
return;
}
RoomDTO roomDTO = roomService.getRoomByRoomId(context.getRoomId());
if (roomDTO == null) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
boolean result = streamService.closeStream(streamId);
log.info("zegoStrategy handleClose.closeStream, stream:{}, result={}", streamId, result);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/factory/StreamFactory.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/factory/StreamFactory.java | package cn.bixin.sona.server.room.factory;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.service.StreamOperation;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
public class StreamFactory {
@Resource(name = "zegoStrategy")
private StreamOperation zegoStrategy;
@Resource(name = "defaultStrategy")
private StreamOperation defaultStrategy;
@Resource(name = "tencentStrategy")
private StreamOperation tencentStrategy;
public StreamOperation newInstance(StreamSupplierEnum streamSupplier) {
if (streamSupplier == StreamSupplierEnum.ZEGO) {
return zegoStrategy;
} else if (streamSupplier == StreamSupplierEnum.TENCENT) {
return tencentStrategy;
}
return defaultStrategy;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/exception/ExceptionCode.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/exception/ExceptionCode.java | package cn.bixin.sona.server.exception;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.dto.Response;
public enum ExceptionCode implements Code {
/**
* 返回错误码定义
*/
ERROR_PARAM("8010","参数错误"),
NULL_PARAM("8011","参数为空"),
EMPTY_PARAM("8012","缺少参数"),
SERVER_ERROR("9000", "服务器异常"),
DATA_NOT_FOUND("8014","数据没有找到"),
PARAM_OVER_MAX("8015","参数超过最大长度"),
ERROR_AUTH("8016", "没有权限操作"),
ERROR_ACCID("8017", "获取accId失败"),
ERROR_PASSWORD("8018", "密码错误"),
OWNER_NOT_FOUND("8019", "房主没有找到"),
ERROR_SEND_MESSAGE("8020", "发送消息失败"),
PARAMETER_LENGTH_IS_TOO_LONG("8021","参数长度过长"),
HTTP_ERROR("8022", "http请求异常"),
DIAMOND_NOT_ENOUGH("8050", "账户钻石不足"),
APP_VERSION_IS_LOW("8023", "当前版本过低，请升级版本"),
CHATROOM_INVALID("10010", "聊天室无效"),
CREATE_CHATROOM_ERROR("10011", "创建房间失败"),
CHECK_ONLINE_ROOM_MEMBER_ERROR("10012", "检查房间在线人员失败"),
OPEN_CLOSE_CHATROOM_ERROR("10013", "开关房间失败"),
CREATOR_NOT_SAME_ERROR("10014", "操作人不是房主"),
CHATROOM_EXISTS("10015", "房间已经存在"),
CHATROOM_NOT_EXISTS("10016", "房间不存在"),
KICK_OUT_ROOM_MEMBER_ERROR("10017", "房间踢人失败"),
GET_ONLINE_ROOM_MEMBER_ERROR("10018", "获取在线成员失败"),
IM_CHATROOM_NOT_FOUNT("10019", "im房间查询未找到"),
RTC_RECORD_NOT_EXISTS("10020", "连麦记录不存在"),
RTC_RECORD_REPETITION("10021", "连麦重复上报"),
RTC_ROOM_NOT_EXISTS("10022", "rtc房间不存在"),
SET_USER_ROLE_ERROR("10023", "设置用户信息失败"),
SET_GROUP_ADMIN_ERROR("10024", "设置群组管理员失败"),
REMOVE_GROUP_ADMIN_ERROR("10025", "移除群组管理员失败"),
GET_GROUP_INFO_ERROR("10026", "获取群组信息失败"),
GET_CHATROOM_INFO_ERROR("10027", "获取聊天室信息失败"),
CREATE_GROUP_ERROR("20010", "创建群组失败"),
GROUP_NOT_FOUND("20011", "群组没有找到"),
GROUP_COUNT_EXCEED("20012", "群人数已经超限"),
JOIN_GROUP_ERROR("20013", "加入群组失败"),
KICK_MEMBER_ERROR("20014", "踢人失败"),
REMOVE_GROUP_ERROR("20015", "解散群组失败"),
QUERY_GROUP_ERROR("20016", "查询群组失败"),
MEMBER_NOT_FOUND("20017", "没有该成员"),
GROUP_MSG_ERROR("20018", "发送群组消息失败"),
LEAVE_GROUP_ERROR("20019", "退群失败"),
ROOM_CLOSED_ERROR("20020", "房间已经关闭"),
HAS_BEEN_BLOCKED("20021", "已经被拉黑，无法进入房间"),
OWNER_LEAVE_GROUP("20022", "群主不能退出群"),
USER_STREAM_EXISTS("300010", "该用户已经创建流"),
STREAM_SUPPLIER_NOT_FOUND("300011", "流供应商没有找到"),
STREAM_PUSH_FORBID("300012", "已被禁流"),
STREAM_ERROR("300013", "流操作失败"),
STREAM_NOT_FOUND("300013", "流id不存在"),
NOT_SUPPORT("300014", "功能暂不支持"),
MIX_STREAM_ERROR("300015", "混流失败"),
STREAM_CHANGE_TYPE_ERROR("300016","上报流改变类型错误"),
PARSE_STREAM_ERROR("300017","解析流失败"),
MIX_STOP_STREAM_ERROR("300016", "取消混流失败"),
NOT_HAVE_USABLE_SUPPLIER("300018", "无可用供应商"),
PRODUCT_NOT_FOUND("400010", "没有该产品"),
PRODUCT_IM_MODEL_ERROR("400011", "imModule错误"),
IM_CONFIG_ERROR("400013", "im配置错误'"),
SUPPLIER_NOT_FOUND("400014", "没有该供应商"),
BALANCE_NOT_ENOUGH("300100", "账户钻石不足"),
NOT_FREE_GIFT("300102", "该礼物不是免费礼物"),
IS_FREE_GIFT("300103", "该礼物不是付费礼物"),
GIFT_TYPE_ERROR("300104","礼物类型错误"),
GIFT_PRICE_ERROR("300105","礼物价格错误"),
FREE_GIFT_IN_TIME("300106", "免费礼物还在倒计时中,请耐心等候..."),
INVALID_GIFT("300107", "礼物已下架，换一个吧！"),
EXPIRED_GIFT("300108", "礼物已过期，请重新打开礼物面板刷新"),
GIFT_ACTIVITY_END("300109", "该礼物的活动已结束"),
PAY_ERROR("300101","支付失败"),
USER_NOT_EXISTS("300110", "用户不存在"),
USER_STATUS_ERROR("300111","用户状态异常"),
Gift_NOT_EXISTS("300112", "礼物不存在"),
Gift_CURRENT_TYPE_ERROR("300113", "礼物支付类型错误"),
TO_UID_NOT_IN_CHATROOM("300114","被打赏人不在聊天室"),
NO_GAME_READY_START("500010", "当前没有游戏准备开始"),
GAME_NUM_ENOUGH("500011", "游戏人数已满"),
GAME_CANCELED("500012", "对方已取消游戏"),
GAME_NOT_FOUND("500013", "游戏没有找到"),
GAME_NOT_FOUND_NOT_NOTIFY("500013", ""),
GAME_NOT_TEAMING_STATUS_ERROR("500014", "游戏不在组队中"),
GAME_INVITE_ERROR("500015", "麦位已满,暂无法邀请用户上麦游戏"),
GAME_END_ERROR("500016", "游戏已经结束"),
GAME_MIC_ERROR("500017", "麦位已满"),
CALL_GAME_ERROR("500018", "调用游戏失败"),
GAME_LIVING_ERROR("500019", "当前房间游戏中，结束后才可发起新游戏"),
START_GAME_ERROR("500020", "发起游戏失败"),
INVOKE_EXCEPTION("99999", "调用异常"),
/**
* web rtc
*/
MULTI_MEDIA_FAILED_CUR_ONLINE("300400","通话正在进行,请结束当前通话"),
MULTI_MEDIA_FAILED_TARGET_ONLINE("300401","对方正在通话,请稍后重试"),
MULTI_MEDIA_FAILED_CUR_VIDEO_TYPE("300402","当前模式正是视频模式"),
MULTI_MEDIA_FAILED_CUR_VERSION_NOT_SUPPORT("300403","对方版本不支持"),
MULTI_MEDIA_FAILED_CUR_USER_NOT_SUPPORT("300404","当前用户不支持该功能"),
MULTI_MEDIA_FAILED_CUR_MEDIA_NOT_EXIST("300405","当前通话不存在"),
MULTI_MEDIA_FAILED_CUR_USER_NOT_POWER("300406","当前用户没有权限"),
MULTI_MEDIA_FAILED_CUR_MEDIA_OPERATE_NOT_EXIST("300407","当前操作不存在"),
MULTI_MEDIA_FAILED_TARGET_USER_NOT_ONLINE("300408","对方暂时未在线"),
;
private String code;
private String message;
ExceptionCode(String code, String message){
this.code = code;
this.message = message;
}
@Override
public String getCode() {
return code;
}
@Override
public String getMessage() {
return message;
}
public Response getFailResponse(){
return Response.fail(this.getCode(),this.getMessage());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/report/controller/MercuryReportController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/report/controller/MercuryReportController.java | package cn.bixin.sona.server.report.controller;
import cn.bixin.sona.api.report.MercuryReportRemoteService;
import cn.bixin.sona.api.report.request.MercuryReportRequest;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.server.report.manager.MercuryReportManager;
import org.apache.dubbo.config.annotation.DubboService;
import javax.annotation.Resource;
@DubboService
public class MercuryReportController implements MercuryReportRemoteService {
@Resource
private MercuryReportManager mercuryReportManager;
@Override
public Response<Boolean> report(MercuryReportRequest request) {
return Response.success(mercuryReportManager.report(request));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/report/manager/MercuryReportManager.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/report/manager/MercuryReportManager.java | package cn.bixin.sona.server.report.manager;
import cn.bixin.sona.api.report.request.MercuryReportRequest;
import cn.bixin.sona.server.mq.KafkaSender;
import com.alibaba.fastjson.JSON;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Objects;
@Component
public class MercuryReportManager {
@Resource
private KafkaSender kafkaSender;
private static final String TOPIC_MERCURY_CLIENT_LOG = "TOPIC-MERCURY_CLIENT_LOG";
public Boolean report(MercuryReportRequest request) {
if (Objects.isNull(request)) {
return false;
}
kafkaSender.send(TOPIC_MERCURY_CLIENT_LOG, JSON.toJSONString(request));
return true;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/config/TraceConfiguration.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/config/TraceConfiguration.java | package cn.bixin.sona.server.config;
import cn.bixin.sona.common.kafka.TraceRecordInterceptor;
import cn.bixin.sona.common.rocket.TraceConsumerHook;
import cn.bixin.sona.common.rocket.TraceSendHook;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author qinwei
*/
@Configuration
public class TraceConfiguration {
@Bean
public TraceRecordInterceptor traceRecordInterceptor() {
return new TraceRecordInterceptor();
}
@Bean
public TraceConsumerHook traceConsumerHook() {
return new TraceConsumerHook();
}
@Bean
public TraceSendHook traceSendHook() {
return new TraceSendHook();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/socket/controller/ChatroomController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/socket/controller/ChatroomController.java | package cn.bixin.sona.server.socket.controller;
import cn.bixin.sona.api.room.SonaRoomQueryRemoteService;
import cn.bixin.sona.api.socket.RoomMessageRemoteService;
import cn.bixin.sona.api.socket.request.BatchChatroomMsgRequest;
import cn.bixin.sona.api.socket.request.ChatroomMsgRequest;
import cn.bixin.sona.api.socket.request.GroupMsgRequest;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.dto.RoomUserDTO;
import cn.bixin.sona.server.socket.service.ChatroomSendService;
import cn.bixin.sona.session.api.UserSessionRemoteService;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* @author qinwei
*/
@Service
public class ChatroomController implements RoomMessageRemoteService {
private UserSessionRemoteService userSessionRemoteService;
@Resource
private ChatroomSendService chatroomSendService;
@Resource
private SonaRoomQueryRemoteService sonaRoomQueryRemoteService;
@Override
public Response<Boolean> closeChatroom(String roomId) {
return Response.success(chatroomSendService.asyncCloseRoom(roomId));
}
@Override
public Response<Boolean> batchKickOutChatroom(ChatroomMsgRequest request, List<Long> toUids) {
return Response.success(chatroomSendService.asyncKickOut(request, toUids.stream().map(Object::toString).collect(Collectors.toList())));
}
@Override
public Response<Boolean> sendChatroom(ChatroomMsgRequest request) {
return Response.success(chatroomSendService.asyncSendMessage(request));
}
@Override
public Response<Boolean> batchSendChatroom(BatchChatroomMsgRequest request) {
return Response.success(chatroomSendService.asyncBatchSendMessage(request));
}
@Override
public Response<Boolean> globalSendChatroom(BatchChatroomMsgRequest request) {
return Response.success(chatroomSendService.asyncGlobalSendMessage(request));
}
@Override
public Response<Boolean> batchSendChatroomMember(ChatroomMsgRequest request, List<Long> toUids) {
return Response.success(chatroomSendService.asyncSendMessage(request, toUids.stream().map(Objects::toString).collect(Collectors.toList())));
}
@Override
public Response<Boolean> sendGroup(GroupMsgRequest request) {
List<String> results = new ArrayList<>();
String anchor = "0";
int limit = 50;
boolean end = false;
while (!end) {
Response<PageResult<RoomUserDTO>> response = sonaRoomQueryRemoteService.getRoomMemberList(Long.parseLong(request.getGroupId()), anchor, limit);
boolean hasData = response.isSuccess() && response.getResult() != null && !CollectionUtils.isEmpty(response.getResult().getList());
if (hasData) {
Response<Map<Long, List<String>>> resp = userSessionRemoteService.getChatRoomOnlineStates(response.getResult().getList().stream().map(RoomUserDTO::getUid).collect(Collectors.toList()));
if (resp.isSuccess()) {
Map<Long, List<String>> result = resp.getResult();
for (List<String> value : result.values()) {
results.addAll(value);
}
}
} else {
break;
}
end = response.getResult().getEnd();
anchor = response.getResult().getAnchor();
}
return Response.success(chatroomSendService.asyncSendGroupMessage(request, results));
}
@Override
public Response<Boolean> sendMsgToGroupMembers(GroupMsgRequest request, List<Long> toUids) {
Response<Map<Long, List<String>>> response = userSessionRemoteService.getChatRoomOnlineStates(toUids);
if (!response.isSuccess()) {
return Response.fail(response.getCode(), response.getMsg());
}
Map<Long, List<String>> result = response.getResult();
List<String> channels = new ArrayList<>();
for (List<String> value : result.values()) {
channels.addAll(value);
}
return Response.success(chatroomSendService.asyncSendGroupMessage(request, channels));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/socket/service/ChatroomSendService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/socket/service/ChatroomSendService.java | package cn.bixin.sona.server.socket.service;
import cn.bixin.sona.api.socket.request.BatchChatroomMsgRequest;
import cn.bixin.sona.api.socket.request.ChatroomMsgRequest;
import cn.bixin.sona.api.socket.request.GroupMsgRequest;
import cn.bixin.sona.server.im.utils.MessageLog;
import cn.bixin.sona.server.mq.RocketSender;
import com.alibaba.fastjson.JSONObject;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author qinwei
*/
@Service
public class ChatroomSendService {
@Resource
private MessageLog messageLog;
@Resource
private RocketSender rocketSender;
private static final String MQ_KEY_CMD = "cmd";
private static final String MQ_KEY_ROOM = "room";
private static final String MQ_KEY_DATA = "data";
private static final String MQ_KEY_SEND_TIME = "sendTime";
private static final String MQ_KEY_MEMBER_LIST = "members";
private static final String MQ_KEY_PRIORITY = "highPriority";
private static final String MQ_KEY_ACK_UIDS = "ackUids";
private static final String MQ_KEY_MESSAGE_ID = "messageId";
private static final String MQ_KEY_SIGNAL = "signal";
public boolean asyncSendMessage(ChatroomMsgRequest request) {
JSONObject param = new JSONObject();
if (request.getSendTime() > 0) {
param.put(MQ_KEY_SEND_TIME, request.getSendTime());
}
if (!CollectionUtils.isEmpty(request.getAckUids())) {
param.put(MQ_KEY_ACK_UIDS, request.getAckUids().stream().map(String::valueOf).collect(Collectors.toList()));
}
param.put(MQ_KEY_ROOM, request.getRoomId());
param.put(MQ_KEY_DATA, request.getContent());
param.put(MQ_KEY_CMD, 12);
param.put(MQ_KEY_PRIORITY, request.isHighPriority());
param.put(MQ_KEY_MESSAGE_ID, request.getMessageId());
return sendChatroom(param);
}
public boolean asyncBatchSendMessage(BatchChatroomMsgRequest request) {
JSONObject param = new JSONObject();
if (request.getSendTime() > 0) {
param.put(MQ_KEY_SEND_TIME, request.getSendTime());
}
if (!CollectionUtils.isEmpty(request.getAckUids())) {
param.put(MQ_KEY_ACK_UIDS, request.getAckUids().stream().map(String::valueOf).collect(Collectors.toList()));
}
param.put("rooms", request.getRoomIds());
param.put(MQ_KEY_DATA, request.getContent());
param.put(MQ_KEY_CMD, 12);
param.put(MQ_KEY_MESSAGE_ID, request.getMessageId());
return sendChatroom(param);
}
public boolean asyncGlobalSendMessage(BatchChatroomMsgRequest request) {
JSONObject param = new JSONObject();
if (request.getSendTime() > 0) {
param.put(MQ_KEY_SEND_TIME, request.getSendTime());
}
if (!CollectionUtils.isEmpty(request.getAckUids())) {
param.put(MQ_KEY_ACK_UIDS, request.getAckUids().stream().map(String::valueOf).collect(Collectors.toList()));
}
param.put("global", true);
param.put(MQ_KEY_DATA, request.getContent());
param.put(MQ_KEY_CMD, 12);
param.put(MQ_KEY_MESSAGE_ID, request.getMessageId());
return sendChatroom(param);
}
public boolean asyncSendMessage(ChatroomMsgRequest request, List<String> toUids) {
JSONObject param = new JSONObject();
if (request.getSendTime() > 0) {
param.put(MQ_KEY_SEND_TIME, request.getSendTime());
}
if (!CollectionUtils.isEmpty(request.getAckUids())) {
param.put(MQ_KEY_ACK_UIDS, request.getAckUids().stream().map(String::valueOf).collect(Collectors.toList()));
}
param.put(MQ_KEY_ROOM, request.getRoomId());
param.put(MQ_KEY_DATA, request.getContent());
param.put(MQ_KEY_MEMBER_LIST, toUids);
param.put(MQ_KEY_CMD, 12);
param.put(MQ_KEY_PRIORITY, request.isHighPriority());
param.put(MQ_KEY_MESSAGE_ID, request.getMessageId());
return sendChatroom(param);
}
public boolean asyncCloseRoom(String roomId) {
JSONObject param = new JSONObject();
param.put(MQ_KEY_ROOM, roomId);
param.put(MQ_KEY_SIGNAL, 2);
param.put(MQ_KEY_DATA, "");
param.put(MQ_KEY_CMD, 13);
return sendChatroom(param);
}
public boolean asyncKickOut(ChatroomMsgRequest request, List<String> members) {
JSONObject param = new JSONObject();
if (!CollectionUtils.isEmpty(request.getAckUids())) {
param.put(MQ_KEY_ACK_UIDS, request.getAckUids().stream().map(String::valueOf).collect(Collectors.toList()));
}
param.put(MQ_KEY_ROOM, request.getRoomId());
param.put(MQ_KEY_MEMBER_LIST, members);
param.put(MQ_KEY_SIGNAL, 1);
param.put(MQ_KEY_DATA, request.getContent());
param.put(MQ_KEY_MESSAGE_ID, request.getMessageId());
param.put(MQ_KEY_CMD, 13);
return sendChatroom(param);
}
private boolean sendChatroom(JSONObject jsonObject) {
String data = jsonObject.getString(MQ_KEY_DATA);
rocketSender.asyncSend("TOPIC_CHATROOM_MESSAGE_SEND", jsonObject.toJSONString(), new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
if (StringUtils.hasText(data)) {
messageLog.saveMessageLog(jsonObject.getString(MQ_KEY_MESSAGE_ID), sendResult.getMsgId());
}
}
@Override
public void onException(Throwable e) {
if (StringUtils.hasText(data)) {
messageLog.saveMessageLog(jsonObject.getString(MQ_KEY_MESSAGE_ID), e.getMessage());
}
}
});
return true;
}
public boolean asyncSendGroupMessage(GroupMsgRequest request, List<String> channels) {
JSONObject param = new JSONObject();
if (request.getSendTime() > 0) {
param.put(MQ_KEY_SEND_TIME, request.getSendTime());
}
param.put(MQ_KEY_ROOM, request.getGroupId());
param.put(MQ_KEY_DATA, request.getContent());
param.put("channels", channels);
param.put(MQ_KEY_CMD, 14);
param.put(MQ_KEY_MESSAGE_ID, request.getMessageId());
rocketSender.asyncSend("TOPIC_GROUP_MESSAGE_SEND", param.toJSONString(), null);
return true;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dto/Code.java | sona-common/src/main/java/cn/bixin/sona/common/dto/Code.java | package cn.bixin.sona.common.dto;
/**
* @author qinwei
*/
public interface Code {
String getCode();
String getMessage();
Code SUCCESS = new Code() {
@Override
public String getCode() {
return "8000";
}
@Override
public String getMessage() {
return "SUCCESS";
}
};
Code ERROR_PARAM = new Code() {
@Override
public String getCode() {
return "8010";
}
@Override
public String getMessage() {
return "参数不正确";
}
};
/**
* 自定义新的code
*/
static Code business(String code, String msg) {
return new Code() {
@Override
public String getCode() {
return code;
}
@Override
public String getMessage() {
return msg;
}
};
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dto/PageResult.java | sona-common/src/main/java/cn/bixin/sona/common/dto/PageResult.java | package cn.bixin.sona.common.dto;
import cn.bixin.sona.common.annotation.Description;
import java.io.Serializable;
import java.util.List;
/**
* @author qinwei
*/
@Description("通用的分页结果")
public class PageResult<T> implements Serializable {
private static final long serialVersionUID = 5305667725145421839L;
@Description("获取的列表数量")
private Long count;
@Description("是否到了最后一页")
private Boolean end;
@Description("分页结果列表")
private List<T> list;
@Description("游标标识")
private String anchor;
@Description("列表为空的提示字符串")
private String emptyMsg;
public static <T> PageResult<T> newPageResult(List<T> list, boolean end) {
PageResult<T> result = new PageResult<>();
result.setEnd(end);
result.setList(list);
return result;
}
public static <T> PageResult<T> newPageResult(List<T> list, boolean end, Long count, String anchor) {
PageResult<T> result = new PageResult<>();
result.setEnd(end);
result.setList(list);
result.setCount(count);
result.setAnchor(anchor);
return result;
}
public Long getCount() {
return count;
}
public void setCount(Long count) {
this.count = count;
}
public Boolean getEnd() {
return end;
}
public void setEnd(Boolean end) {
this.end = end;
}
public List<T> getList() {
return list;
}
public void setList(List<T> list) {
this.list = list;
}
public String getAnchor() {
return anchor;
}
public void setAnchor(String anchor) {
this.anchor = anchor;
}
public String getEmptyMsg() {
return emptyMsg;
}
public void setEmptyMsg(String emptyMsg) {
this.emptyMsg = emptyMsg;
}
@Override
public String toString() {
return "PageResult{" +
"count=" + count +
", end=" + end +
", list=" + list +
", anchor='" + anchor + '\'' +
", emptyMsg='" + emptyMsg + '\'' +
'}';
}
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dto/Response.java | sona-common/src/main/java/cn/bixin/sona/common/dto/Response.java | package cn.bixin.sona.common.dto;
import cn.bixin.sona.common.annotation.Description;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* @author qinwei
*/
public class Response<T> implements Serializable {
private static final long serialVersionUID = -4676464238372114010L;
@Description("自定义的业务code码，8000表示业务请求成功，非8000表示业务异常")
private String code;
@Description("业务异常的提示信息,成功的请求此字段为空")
private String msg;
@Description("请求是成功还是异常 true成功，false异常")
private boolean success;
@Description("请求成功后返回的信息")
private T result;
@Description("traceId")
private String tid;
@Description("扩展信息")
private Map<String, Object> ext;
public String getCode() {
return code;
}
public String getMsg() {
return msg;
}
public boolean isSuccess() {
return success;
}
public T getResult() {
return result;
}
public void setResult(T result) {
this.result = result;
}
public String getTid() {
return tid;
}
public void setTid(String tid) {
this.tid = tid;
}
public Map<String, Object> getExt() {
return ext;
}
public void setExt(Map<String, Object> ext) {
this.ext = ext;
}
public Response<T> putExt(String key, Object value) {
if (this.ext == null) {
this.ext = new HashMap<>(1);
}
this.ext.put(key, value);
return this;
}
public static <T> Response<T> success(T data) {
return generateResponse(true, Code.SUCCESS, data, null);
}
public static <T> Response<T> fail(String code, String msg) {
return fail(Code.business(code, msg));
}
public static <T> Response<T> fail(String code, String msg, Map<String, Object> ext) {
return fail(Code.business(code, msg), ext);
}
public static <T> Response<T> fail(Code code) {
return generateResponse(false, code, null, null);
}
public static <T> Response<T> fail(Code code, Map<String, Object> ext) {
return generateResponse(false, code, null, ext);
}
private static <T> Response<T> generateResponse(boolean success, Code code, T data, Map<String, Object> ext) {
Response<T> response = new Response<>();
response.code = code.getCode();
response.msg = code.getMessage();
response.success = success;
response.result = data;
response.ext = ext;
return response;
}
@Override
public String toString() {
return "Response{" +
"code='" + code + '\'' +
", msg='" + msg + '\'' +
", success=" + success +
", result=" + result +
", tid='" + tid + '\'' +
", ext=" + ext +
'}';
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/util/IdGenerator.java | sona-common/src/main/java/cn/bixin/sona/common/util/IdGenerator.java | package cn.bixin.sona.common.util;
import org.apache.dubbo.common.utils.NetUtils;
import org.springframework.stereotype.Service;
import java.time.Instant;
/**
* @author qinwei
*/
@Service
public class IdGenerator {
private static final int TOTAL_BITS = 64;
private static final int EPOCH_BITS = 40;
private static final int NODE_IP_BITS = 16;
private static final int SEQUENCE_BITS = 8;
/**
* Custom Epoch (January 1, 2015 Midnight UTC = 2015-01-01T00:00:00Z)
*
* @param UTC
* @return
*/
private static final long CUSTOM_EPOCH = 1420070400000L;
/**
* 255.255.255.255
* 取后16位ip地址
*/
private static final int NODE_IP = createNodeId();
private static final int MAX_SEQUENCE = (int) (Math.pow(2, SEQUENCE_BITS) - 1);
private long lastTimestamp = -1L;
private long sequence = 0L;
public long id() {
long currentTimestamp = timestamp();
synchronized (this) {
if (currentTimestamp == lastTimestamp) {
sequence = (sequence + 1) & MAX_SEQUENCE;
if (sequence == 0) {
// Sequence Exhausted, wait till next millisecond.
currentTimestamp = waitNextMillis(currentTimestamp);
}
} else {
// reset sequence to start with zero for the next millisecond
sequence = 0;
}
lastTimestamp = currentTimestamp;
}
long id = currentTimestamp << (TOTAL_BITS - EPOCH_BITS);
id |= (NODE_IP << (TOTAL_BITS - EPOCH_BITS - NODE_IP_BITS));
id |= sequence;
return id;
}
public String strId() {
return String.valueOf(id());
}
/**
* 获取指定时间戳对应的id序号
* 注意！！不用于生成消息id，仅用于查询
*
* @param timestamp
* @return
*/
public String getSpecialSequenceId(long timestamp) {
long specialTimestamp = timestamp - CUSTOM_EPOCH;
long id = specialTimestamp << (TOTAL_BITS - EPOCH_BITS);
id |= (NODE_IP << (TOTAL_BITS - EPOCH_BITS - NODE_IP_BITS));
return String.valueOf(id);
}
/**
* 获取指定时间戳对应的id序号
* 注意！！不用于生成消息id，仅用于查询
*
* @param timestamp
* @return
*/
public String getSequenceIdWithoutNodeId(long timestamp) {
long specialTimestamp = timestamp - CUSTOM_EPOCH;
long id = specialTimestamp << (TOTAL_BITS - EPOCH_BITS);
return String.valueOf(id);
}
/**
* 获取 sequenceId 对应 时间戳
*
* @param sequenceId
* @return
*/
public long getTimestampFromSequenceId(long sequenceId) {
return (sequenceId >> (TOTAL_BITS - EPOCH_BITS)) + CUSTOM_EPOCH;
}
private static long timestamp() {
return Instant.now().toEpochMilli() - CUSTOM_EPOCH;
}
private static int createNodeId() {
String[] split = NetUtils.getLocalHost().split("\\.");
return (Integer.parseInt(split[2]) << 8) + Integer.parseInt(split[3]);
}
private long waitNextMillis(long currentTimestamp) {
while (currentTimestamp == lastTimestamp) {
currentTimestamp = timestamp();
}
return currentTimestamp;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/DubboCat.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/DubboCat.java | package cn.bixin.sona.common.dubbo;
import com.dianping.cat.Cat;
/**
* @author qinwei
*/
public class DubboCat {
private static boolean isEnable = true;
/**
* 禁用dubbo cat
*/
public static void disable() {
isEnable = false;
}
/**
* 启用dubbo cat
*/
public static void enable() {
isEnable = true;
}
/**
* 是否有效
*
* @return
*/
public static boolean isEnable() {
return Cat.getManager().isCatEnabled() && isEnable;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/AppNameAppendFilter.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/AppNameAppendFilter.java | package cn.bixin.sona.common.dubbo.filter;
import com.alibaba.dubbo.common.Constants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
/**
* @author qinwei
*/
@Activate(group = {Constants.CONSUMER})
public class AppNameAppendFilter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
RpcContext.getContext().setAttachment(Constants.APPLICATION_KEY, invoker.getUrl().getParameter(Constants.APPLICATION_KEY));
return invoker.invoke(invocation);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/ProviderTraceFilter.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/ProviderTraceFilter.java | package cn.bixin.sona.common.dubbo.filter;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.trace.TracerContext;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import org.springframework.core.Ordered;
/**
* @author qinwei
*/
@Activate(group = CommonConstants.PROVIDER, order = Ordered.LOWEST_PRECEDENCE - 3)
public class ProviderTraceFilter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
TraceHelper.setTraceId(RpcContext.getContext().getAttachment(TracerContext.TRACER_TRACE_ID));
return invoker.invoke(invocation);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/ConsumerTraceFilter.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/ConsumerTraceFilter.java | package cn.bixin.sona.common.dubbo.filter;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.trace.TracerContext;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import org.springframework.core.Ordered;
/**
* @author qinwei
*/
@Activate(group = CommonConstants.CONSUMER, order = Ordered.HIGHEST_PRECEDENCE)
public class ConsumerTraceFilter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
RpcContext.getContext().setAttachment(TracerContext.TRACER_TRACE_ID, TraceHelper.getTraceId());
return invoker.invoke(invocation);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/HibernateValidationFilter.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/HibernateValidationFilter.java | package cn.bixin.sona.common.dubbo.filter;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.dto.Response;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.common.utils.ArrayUtils;
import org.apache.dubbo.config.spring.extension.SpringExtensionFactory;
import org.apache.dubbo.rpc.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.core.Ordered;
import org.springframework.util.CollectionUtils;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.executable.ExecutableValidator;
import java.lang.reflect.Method;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinwei
*/
@Activate(group = CommonConstants.PROVIDER, order = Ordered.LOWEST_PRECEDENCE - 1)
public class HibernateValidationFilter implements Filter {
private static final Logger log = LoggerFactory.getLogger(HibernateValidationFilter.class);
private final Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
if (invocation.getMethodName().startsWith("$")) {
return invoker.invoke(invocation);
}
Class<?> service = invoker.getInterface();
Method method;
try {
method = service.getMethod(invocation.getMethodName(), invocation.getParameterTypes());
} catch (NoSuchMethodException e) {
log.warn("call={}.{} reflect method error. ", service.getSimpleName(), invocation.getMethodName());
return invoker.invoke(invocation);
}
Set<ApplicationContext> contexts = SpringExtensionFactory.getContexts();
if (CollectionUtils.isEmpty(contexts)) {
return invoker.invoke(invocation);
}
Map<String, ?> beansMap = contexts.iterator().next().getBeansOfType(service);
if (beansMap.isEmpty()) {
return invoker.invoke(invocation);
}
Object serviceInstance = beansMap.values().stream().findAny().orElse(null);
if (invalid(serviceInstance, method, invocation.getArguments())) {
Response<Object> response = null;
if (Response.class.isAssignableFrom(method.getReturnType())) {
response = Response.fail(Code.ERROR_PARAM);
}
Result result = AsyncRpcResult.newDefaultAsyncResult(response, null, invocation);
result.setAttachments(invocation.getAttachments());
return result;
}
return invoker.invoke(invocation);
}
private boolean invalid(Object validateParamService, Method method, Object[] args) {
return !methodArgsValidate(validateParamService, method, args)
|| !methodArgsFieldValidate(method, args);
}
private boolean methodArgsFieldValidate(Method method, Object[] args) {
if (ArrayUtils.isEmpty(args)) {
return true;
}
List<ConstraintViolation<Object>> error = Arrays.stream(args)
.filter(Objects::nonNull)
.map(validator::validate)
.flatMap(Collection::stream)
.collect(Collectors.toList());
if (CollectionUtils.isEmpty(error)) {
return true;
}
List<String> errorMessage = error.stream().map(i -> i.getPropertyPath() + " " + i.getMessage()).collect(Collectors.toList());
log.warn("methodArgsFieldValidate failed. method={}, message={}", method.getName(), errorMessage);
return false;
}
private boolean methodArgsValidate(Object validateParamService, Method method, Object[] args) {
if (ArrayUtils.isEmpty(args)) {
return true;
}
ExecutableValidator executableValidator = validator.forExecutables();
Set<ConstraintViolation<Object>> constraintViolationSet = executableValidator.validateParameters(validateParamService, method, args);
if (CollectionUtils.isEmpty(constraintViolationSet)) {
return true;
}
List<String> errorMessage = constraintViolationSet.stream().map(i -> i.getPropertyPath() + " " + i.getMessage()).collect(Collectors.toList());
log.warn("methodArgsValidate failed. message={}", errorMessage);
return false;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/CommonExecutorFilter.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/CommonExecutorFilter.java | package cn.bixin.sona.common.dubbo.filter;
import cn.bixin.sona.common.annotation.CommonExecutor;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.common.exception.YppRunTimeException;
import com.alibaba.fastjson.JSON;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import javax.validation.ConstraintViolationException;
import java.lang.reflect.Method;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletionException;
/**
* @author qinwei
*/
@Activate(group = CommonConstants.PROVIDER, order = Ordered.LOWEST_PRECEDENCE - 2)
public class CommonExecutorFilter implements Filter {
private static final Logger log = LoggerFactory.getLogger(CommonExecutorFilter.class);
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
if (invocation.getMethodName().startsWith("$")) {
return invoker.invoke(invocation);
}
Class<?> service = invoker.getInterface();
String methodName = invocation.getMethodName();
Object[] arguments = invocation.getArguments();
Method method;
try {
method = service.getMethod(methodName, invocation.getParameterTypes());
} catch (NoSuchMethodException e) {
log.warn("call={}.{} reflect method error. ", service.getSimpleName(), methodName);
return invoker.invoke(invocation);
}
Result result = invoker.invoke(invocation);
if (method.isAnnotationPresent(CommonExecutor.class)) {
CommonExecutor commonExecutor = method.getAnnotation(CommonExecutor.class);
if (commonExecutor.printParam()) {
log.info("call={}.{},params={}", service.getSimpleName(), methodName, JSON.toJSONString(arguments));
}
if (commonExecutor.printResponse()) {
log.info("call={}.{} hasException={},result={}", service.getSimpleName(), methodName, result.hasException(), JSON.toJSONString(result.getValue()));
}
}
if (!result.hasException()) {
return result;
}
resetErrorResultValue(result, service.getSimpleName(), method);
return result;
}
private void resetErrorResultValue(Result result, String serviceName, Method method) {
Throwable exception = result.getException();
if (exception instanceof YppRunTimeException) {
resetYppRuntimeExceptionResult(result, (YppRunTimeException) exception, serviceName, method);
} else if (exception instanceof ConstraintViolationException) {
Object response = null;
if (Response.class.isAssignableFrom(method.getReturnType())) {
response = Response.fail(Code.ERROR_PARAM);
}
result.setValue(response);
} else if (exception instanceof CompletionException || exception instanceof CancellationException) {
Throwable throwable = exception.getCause();
if (throwable instanceof YppRunTimeException) {
resetYppRuntimeExceptionResult(result, (YppRunTimeException) throwable, serviceName, method);
} else {
resetSystemErrorCodeResult(result, exception, serviceName, method);
}
} else {
resetSystemErrorCodeResult(result, exception, serviceName, method);
}
result.setException(null);
}
private void resetYppRuntimeExceptionResult(Result result, YppRunTimeException ex, String serviceName, Method method) {
log.warn("YppRunTimeException. service={},method={},code={},message={}", serviceName, method.getName(), ex.getCode().getCode(), ex.getCode().getMessage());
Object response = null;
if (Response.class.isAssignableFrom(method.getReturnType())) {
response = Response.fail(ex.getCode(), ex.getExt());
}
result.setValue(response);
}
private void resetSystemErrorCodeResult(Result result, Throwable exception, String serviceName, Method method) {
Object response = null;
if (Response.class.isAssignableFrom(method.getReturnType())) {
response = Response.fail(Code.business("9000", "服务异常"));
}
result.setValue(response);
log.error("call={}.{} error.", serviceName, method.getName(), exception);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/ExceptionFilter.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/ExceptionFilter.java | package cn.bixin.sona.common.dubbo.filter;
import cn.bixin.sona.common.dto.Response;
import com.dianping.cat.Cat;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Method;
import java.util.Arrays;
import static cn.bixin.sona.common.exception.RpcExceptionCode.*;
/**
* @author qinwei
*/
@Activate(group = CommonConstants.CONSUMER, order = -10000000)
public class ExceptionFilter implements Filter {
private static final Logger log = LoggerFactory.getLogger(ExceptionFilter.class);
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
Result result;
Class returnType = getReturnType(invoker, invocation);
try {
result = invoker.invoke(invocation);
} catch (RpcException e) {
if (Response.class.isAssignableFrom(returnType)) {
return handleRpcException(invoker, invocation, e);
} else {
logRpcException(invoker, invocation, e);
throw e;
}
} catch (Exception e) {
logUnknownException(invoker, invocation, e);
throw e;
}
return result;
}
public Result handleRpcException(Invoker<?> invoker, Invocation invocation, RpcException e) {
logRpcException(invoker, invocation, e);
Response response;
if (e.isNetwork()) {
response = Response.fail(NETWORK_EXCEPTION);
} else if (e.isTimeout()) {
response = Response.fail(TIMEOUT_EXCEPTION);
} else if (e.isBiz()) {
response = Response.fail(BIZ_EXCEPTION);
} else if (e.isForbidded()) {
response = Response.fail(FORBIDDEN_EXCEPTION);
} else if (e.isSerialization()) {
response = Response.fail(SERIALIZATION_EXCEPTION);
} else {
response = Response.fail(UNKNOWN_EXCEPTION);
}
return AsyncRpcResult.newDefaultAsyncResult(response, null, invocation);
}
public void logRpcException(Invoker<?> invoker, Invocation invocation, RpcException e) {
String name = invoker.getInterface().getName() + '.' + invocation.getMethodName();
if (e.getCause() != null) {
log.error("invoke occur RpcException:" + e.getCause().getClass().getName() + ". method: " + invocation.getMethodName()
+ " arguments: " + Arrays.toString(invocation.getArguments()) + " , url is " + invoker.getUrl(), e);
Cat.logEvent("Exception: " + e.getCause().getClass().getSimpleName(), name);
} else {
log.error("invoke occur RpcException:" + ". method: " + invocation.getMethodName()
+ " arguments: " + Arrays.toString(invocation.getArguments()) + " , url is " + invoker.getUrl(), e);
Cat.logEvent("Exception: UNKNOW", name);
}
}
public void logUnknownException(Invoker<?> invoker, Invocation invocation, Throwable e) {
log.error("Got unchecked and undeclared exception which called by " + RpcContext.getContext().getRemoteHost()
+ ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName()
+ ", exception: " + e.getClass().getName() + ": " + e.getMessage(), e);
Cat.logEvent("Exception:" + e.getClass().getSimpleName(), invoker.getInterface().getName() + '.' + invocation.getMethodName());
}
public Class<?> getReturnType(Invoker<?> invoker, Invocation invocation) {
Class<?> clazz = invoker.getInterface();
Method method = null;
try {
method = clazz.getMethod(invocation.getMethodName(), invocation.getParameterTypes());
} catch (NoSuchMethodException e) {
log.error("Nosuch method exception" + RpcContext.getContext().getRemoteHost()
+ ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName(), e);
}
if (method != null) {
return method.getReturnType();
}
return Object.class;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/CatTransaction.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/filter/CatTransaction.java | package cn.bixin.sona.common.dubbo.filter;
import cn.bixin.sona.common.dubbo.DubboCat;
import cn.bixin.sona.common.dubbo.constants.CatConstants;
import com.alibaba.dubbo.common.Constants;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Event;
import com.dianping.cat.message.Message;
import com.dianping.cat.message.Transaction;
import com.dianping.cat.message.internal.AbstractMessage;
import org.apache.commons.lang.StringUtils;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.remoting.RemotingException;
import org.apache.dubbo.remoting.TimeoutException;
import org.apache.dubbo.rpc.*;
import java.util.HashMap;
import java.util.Map;
/**
* @author qinwei
*/
@Activate(group = {Constants.PROVIDER, Constants.CONSUMER}, order = -9000)
public class CatTransaction implements Filter {
private final static String DUBBO_BIZ_ERROR = "DUBBO_BIZ_ERROR";
private final static String DUBBO_TIMEOUT_ERROR = "DUBBO_TIMEOUT_ERROR";
private final static String DUBBO_REMOTING_ERROR = "DUBBO_REMOTING_ERROR";
private static final ThreadLocal<Cat.Context> CAT_CONTEXT = new ThreadLocal<Cat.Context>();
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
if (!DubboCat.isEnable()) {
return invoker.invoke(invocation);
}
URL url = invoker.getUrl();
String sideKey = url.getParameter(Constants.SIDE_KEY);
String loggerName = invoker.getInterface().getSimpleName() + "." + invocation.getMethodName();
String type = CatConstants.CROSS_CONSUMER;
if (Constants.PROVIDER_SIDE.equals(sideKey)) {
type = CatConstants.CROSS_SERVER;
}
Transaction transaction = Cat.newTransaction(type, loggerName);
Result result = null;
try {
Cat.Context context = getContext();
if (Constants.CONSUMER_SIDE.equals(sideKey)) {
createConsumerCross(url, transaction);
Cat.logRemoteCallClient(context);
} else {
createProviderCross(url, transaction);
Cat.logRemoteCallServer(context);
}
setAttachment(context);
result = invoker.invoke(invocation);
if (result.hasException()) {
//给调用接口出现异常进行打点
Throwable throwable = result.getException();
Event event = null;
if (RpcException.class == throwable.getClass()) {
Throwable caseBy = throwable.getCause();
if (caseBy != null && caseBy.getClass() == TimeoutException.class) {
event = Cat.newEvent(DUBBO_TIMEOUT_ERROR, loggerName);
} else {
event = Cat.newEvent(DUBBO_REMOTING_ERROR, loggerName);
}
} else if (RemotingException.class.isAssignableFrom(throwable.getClass())) {
event = Cat.newEvent(DUBBO_REMOTING_ERROR, loggerName);
} else {
event = Cat.newEvent(DUBBO_BIZ_ERROR, loggerName);
}
event.setStatus(result.getException());
completeEvent(event);
transaction.addChild(event);
transaction.setStatus(result.getException().getClass().getSimpleName());
} else {
transaction.setStatus(Message.SUCCESS);
}
return result;
} catch (RuntimeException e) {
Cat.logError(e);
Event event = null;
if (RpcException.class == e.getClass()) {
Throwable caseBy = e.getCause();
if (caseBy != null && caseBy.getClass() == TimeoutException.class) {
event = Cat.newEvent(DUBBO_TIMEOUT_ERROR, loggerName);
} else {
event = Cat.newEvent(DUBBO_REMOTING_ERROR, loggerName);
}
} else {
event = Cat.newEvent(DUBBO_BIZ_ERROR, loggerName);
}
event.setStatus(e);
completeEvent(event);
transaction.addChild(event);
transaction.setStatus(e.getClass().getSimpleName());
if (result == null) {
throw e;
} else {
return result;
}
} finally {
transaction.complete();
CAT_CONTEXT.remove();
}
}
static class DubboCatContext implements Cat.Context {
private Map<String, String> properties = new HashMap<String, String>();
@Override
public void addProperty(String key, String value) {
properties.put(key, value);
}
@Override
public String getProperty(String key) {
return properties.get(key);
}
}
private String getProviderAppName(URL url) {
String appName = url.getParameter(CatConstants.PROVIDER_APPLICATION_NAME);
if (StringUtils.isEmpty(appName)) {
String interfaceName = url.getParameter(Constants.INTERFACE_KEY);
appName = interfaceName.substring(0, interfaceName.lastIndexOf('.'));
}
return appName;
}
private void setAttachment(Cat.Context context) {
RpcContext.getContext().setAttachment(Cat.Context.ROOT, context.getProperty(Cat.Context.ROOT));
RpcContext.getContext().setAttachment(Cat.Context.CHILD, context.getProperty(Cat.Context.CHILD));
RpcContext.getContext().setAttachment(Cat.Context.PARENT, context.getProperty(Cat.Context.PARENT));
}
private Cat.Context getContext() {
Cat.Context context = CAT_CONTEXT.get();
if (context == null) {
context = initContext();
CAT_CONTEXT.set(context);
}
return context;
}
private Cat.Context initContext() {
Cat.Context context = new DubboCatContext();
Map<String, String> attachments = RpcContext.getContext().getAttachments();
if (attachments != null && !attachments.isEmpty()) {
for (Map.Entry<String, String> entry : attachments.entrySet()) {
if (Cat.Context.CHILD.equals(entry.getKey()) || Cat.Context.ROOT.equals(entry.getKey()) || Cat.Context.PARENT.equals(entry.getKey())) {
context.addProperty(entry.getKey(), entry.getValue());
}
}
}
return context;
}
private void createConsumerCross(URL url, Transaction transaction) {
Event crossAppEvent = Cat.newEvent(CatConstants.CONSUMER_CALL_APP, getProviderAppName(url));
Event crossServerEvent = Cat.newEvent(CatConstants.CONSUMER_CALL_SERVER, url.getHost());
Event crossPortEvent = Cat.newEvent(CatConstants.CONSUMER_CALL_PORT, url.getPort() + "");
crossAppEvent.setStatus(Event.SUCCESS);
crossServerEvent.setStatus(Event.SUCCESS);
crossPortEvent.setStatus(Event.SUCCESS);
completeEvent(crossAppEvent);
completeEvent(crossPortEvent);
completeEvent(crossServerEvent);
transaction.addChild(crossAppEvent);
transaction.addChild(crossPortEvent);
transaction.addChild(crossServerEvent);
}
private void completeEvent(Event event) {
AbstractMessage message = (AbstractMessage) event;
message.setCompleted(true);
}
private void createProviderCross(URL url, Transaction transaction) {
String consumerAppName = RpcContext.getContext().getAttachment(Constants.APPLICATION_KEY);
if (StringUtils.isEmpty(consumerAppName)) {
consumerAppName = RpcContext.getContext().getRemoteHost() + ":" + RpcContext.getContext().getRemotePort();
}
Event crossAppEvent = Cat.newEvent(CatConstants.PROVIDER_CALL_APP, consumerAppName);
Event crossServerEvent = Cat.newEvent(CatConstants.PROVIDER_CALL_SERVER, RpcContext.getContext().getRemoteHost());
crossAppEvent.setStatus(Event.SUCCESS);
crossServerEvent.setStatus(Event.SUCCESS);
completeEvent(crossAppEvent);
completeEvent(crossServerEvent);
transaction.addChild(crossAppEvent);
transaction.addChild(crossServerEvent);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/registry/CatRegistryFactoryWrapper.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/registry/CatRegistryFactoryWrapper.java | package cn.bixin.sona.common.dubbo.registry;
import cn.bixin.sona.common.dubbo.constants.CatConstants;
import com.alibaba.dubbo.common.Constants;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.registry.NotifyListener;
import org.apache.dubbo.registry.Registry;
import org.apache.dubbo.registry.RegistryFactory;
import java.util.List;
/**
* @author qinwei
*/
public class CatRegistryFactoryWrapper implements RegistryFactory {
private RegistryFactory registryFactory;
public CatRegistryFactoryWrapper(RegistryFactory registryFactory) {
this.registryFactory = registryFactory;
}
@Override
public Registry getRegistry(URL url) {
return new CatRegistryFactoryWrapper.RegistryWrapper(registryFactory.getRegistry(url));
}
class RegistryWrapper implements Registry {
private Registry originRegistry;
private URL appendProviderAppName(URL url) {
String side = url.getParameter(Constants.SIDE_KEY);
if (Constants.PROVIDER_SIDE.equals(side)) {
url = url.addParameter(CatConstants.PROVIDER_APPLICATION_NAME, url.getParameter(Constants.APPLICATION_KEY));
}
return url;
}
public RegistryWrapper(Registry originRegistry) {
this.originRegistry = originRegistry;
}
@Override
public URL getUrl() {
return originRegistry.getUrl();
}
@Override
public boolean isAvailable() {
return originRegistry.isAvailable();
}
@Override
public void destroy() {
originRegistry.destroy();
}
@Override
public void register(URL url) {
originRegistry.register(appendProviderAppName(url));
}
@Override
public void unregister(URL url) {
originRegistry.unregister(appendProviderAppName(url));
}
@Override
public void subscribe(URL url, NotifyListener listener) {
originRegistry.subscribe(url, listener);
}
@Override
public void unsubscribe(URL url, NotifyListener listener) {
originRegistry.unsubscribe(url, listener);
}
@Override
public List<URL> lookup(URL url) {
return originRegistry.lookup(appendProviderAppName(url));
}
}
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/dubbo/constants/CatConstants.java | sona-common/src/main/java/cn/bixin/sona/common/dubbo/constants/CatConstants.java | package cn.bixin.sona.common.dubbo.constants;
/**
* @author qinwei
*/
public class CatConstants {
public static final String CROSS_CONSUMER ="PigeonCall";
public static final String CROSS_SERVER = "PigeonService";
public static final String PROVIDER_APPLICATION_NAME="serverApplicationName";
public static final String CONSUMER_CALL_SERVER="PigeonCall.server";
public static final String CONSUMER_CALL_APP="PigeonCall.app";
public static final String CONSUMER_CALL_PORT="PigeonCall.port";
public static final String PROVIDER_CALL_SERVER="PigeonService.client";
public static final String PROVIDER_CALL_APP="PigeonService.app";
public static final String FORK_MESSAGE_ID="m_forkedMessageId";
public static final String FORK_ROOT_MESSAGE_ID="m_rootMessageId";
public static final String FORK_PARENT_MESSAGE_ID="m_parentMessageId";
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/rocket/TraceSendHook.java | sona-common/src/main/java/cn/bixin/sona/common/rocket/TraceSendHook.java | package cn.bixin.sona.common.rocket;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.trace.TracerContext;
import org.apache.rocketmq.client.hook.SendMessageContext;
import org.apache.rocketmq.client.hook.SendMessageHook;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @author qinwei
*/
public class TraceSendHook implements SendMessageHook, InitializingBean {
@Autowired
private DefaultMQProducer defaultMQProducer;
@Override
public String hookName() {
return "TraceSendHook";
}
@Override
public void sendMessageBefore(SendMessageContext context) {
context.getMessage().getProperties().put(TracerContext.TRACER_TRACE_ID, TraceHelper.getTraceId());
}
@Override
public void sendMessageAfter(SendMessageContext context) {
}
@Override
public void afterPropertiesSet() throws Exception {
defaultMQProducer.getDefaultMQProducerImpl().registerSendMessageHook(this);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/rocket/TraceConsumerHook.java | sona-common/src/main/java/cn/bixin/sona/common/rocket/TraceConsumerHook.java | package cn.bixin.sona.common.rocket;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.trace.TracerContext;
import org.apache.rocketmq.common.message.MessageExt;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.util.StringUtils;
import java.util.Arrays;
/**
* @author qinwei
*/
@Order
@Aspect
public class TraceConsumerHook {
@Around("execution (* org.apache.rocketmq.spring.core.RocketMQListener.onMessage(..))")
public Object intercept(ProceedingJoinPoint pjp) throws Throwable {
MessageExt messageExt = Arrays.stream(pjp.getArgs())
.filter(MessageExt.class::isInstance)
.findFirst()
.map(MessageExt.class::cast).orElseGet(null);
if (messageExt == null) {
return pjp.proceed();
}
String traceId = messageExt.getProperties().get(TracerContext.TRACER_TRACE_ID);
if (StringUtils.hasText(traceId)) {
TraceHelper.setTraceId(traceId);
} else {
TraceHelper.init();
}
try {
return pjp.proceed();
} finally {
TraceHelper.reset();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/exception/YppRunTimeException.java | sona-common/src/main/java/cn/bixin/sona/common/exception/YppRunTimeException.java | package cn.bixin.sona.common.exception;
import cn.bixin.sona.common.dto.Code;
import java.text.MessageFormat;
import java.util.Map;
/**
* @author qinwei
*/
public class YppRunTimeException extends RuntimeException {
private static final long serialVersionUID = 1826674764451920773L;
private Code code;
private Map<String, Object> ext;
public YppRunTimeException(Code code) {
super(code.getMessage());
this.code = code;
}
public YppRunTimeException(Code code, Map<String, Object> ext) {
super(code.getMessage());
this.code = code;
this.ext = ext;
}
public Code getCode() {
return this.code;
}
public Map<String, Object> getExt() {
return this.ext;
}
public void setExt(Map<String, Object> ext) {
this.ext = ext;
}
@Override
public Throwable fillInStackTrace() {
return this;
}
@Override
public String toString() {
return MessageFormat.format("业务异常{0}:{1}", this.code.getCode(), this.code.getMessage());
}
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/exception/RpcExceptionCode.java | sona-common/src/main/java/cn/bixin/sona/common/exception/RpcExceptionCode.java | package cn.bixin.sona.common.exception;
import cn.bixin.sona.common.dto.Code;
/**
* @author qinwei
*/
public enum RpcExceptionCode implements Code {
UNKNOWN_EXCEPTION("9999", "未知异常"),
NETWORK_EXCEPTION("9998", "网络异常"),
TIMEOUT_EXCEPTION("9997", "超时异常"),
BIZ_EXCEPTION("9996", "业务异常"),
FORBIDDEN_EXCEPTION("9995", "服务不可用"),
SERIALIZATION_EXCEPTION("9994", "序列化异常");
private String code;
private String message;
RpcExceptionCode(String code, String message) {
this.code = code;
this.message = message;
}
@Override
public String getCode() {
return this.code;
}
@Override
public String getMessage() {
return this.message;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/trace/TracerContext.java | sona-common/src/main/java/cn/bixin/sona/common/trace/TracerContext.java | package cn.bixin.sona.common.trace;
import org.slf4j.MDC;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author qinwei
*/
public class TracerContext {
public static final String TRACER_TRACE_ID = "trace_id";
private final Map<String, String> attachment = new ConcurrentHashMap<>();
private static final ThreadLocal<TracerContext> CONTEXT_HOLDER = ThreadLocal.withInitial(TracerContext::new);
private TracerContext() {
}
public void put(String key, String value) {
if (key == null || value == null) {
return;
}
attachment.put(key, value);
MDC.put(key, value);
}
public String get(String key) {
return key == null || key.isEmpty() ? null : attachment.get(key);
}
public Map<String, String> copyAttachment() {
return new HashMap<>(attachment);
}
public static TracerContext getContext() {
return CONTEXT_HOLDER.get();
}
public static void remove() {
CONTEXT_HOLDER.remove();
MDC.remove(TRACER_TRACE_ID);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/trace/TraceHelper.java | sona-common/src/main/java/cn/bixin/sona/common/trace/TraceHelper.java | package cn.bixin.sona.common.trace;
import org.springframework.util.StringUtils;
import java.util.UUID;
/**
* @author qinwei
*/
public class TraceHelper {
public static TracerContext init() {
TracerContext context = TracerContext.getContext();
String traceId = context.get(TracerContext.TRACER_TRACE_ID);
if (!StringUtils.hasText(traceId)) {
traceId = generateTraceId();
context.put(TracerContext.TRACER_TRACE_ID, traceId);
}
return context;
}
public static String getTraceId() {
return init().get(TracerContext.TRACER_TRACE_ID);
}
public static void reset() {
TracerContext.remove();
}
public static void runWithInitAndReset(Runnable runnable) {
init();
try {
runnable.run();
} finally {
reset();
}
}
public static void setTraceId(String traceId) {
TracerContext.getContext().put(TracerContext.TRACER_TRACE_ID, traceId);
}
public static String generateTraceId() {
return UUID.randomUUID().toString().replace("-", "");
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/hbase/HBaseRepository.java | sona-common/src/main/java/cn/bixin/sona/common/hbase/HBaseRepository.java | package cn.bixin.sona.common.hbase;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.exception.YppRunTimeException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
public class HBaseRepository {
public static final String HBASE_READ_EXCEPTION_CODE = "8999";
public static final String HBASE_DELETE_EXCEPTION_CODE = "8998";
public static final String HBASE_INCREMENT_EXCEPTION_CODE = "8997";
public static final String HBASE_PUT_EXCEPTION_CODE = "8996";
public static final String HBASE_SCAN_EXCEPTION_CODE = "8995";
public static final String HBASE_EXECUTE_EXCEPTION_CODE = "8994";
private Connection connection;
private HBaseRepository(Connection connection) {
this.connection = connection;
}
public static HBaseRepository getInstance(Connection connection){
return new HBaseRepository(connection);
}
public Connection getConnection(){
return connection;
}
/**
* 查询单个结果 get
* @param tbName
* @param rowKey
* @return
*/
public Result get(String tbName, byte[] rowKey) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
return table.get(new Get(rowKey));
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_READ_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 查询列表 gets
*
* @param tbName
* @param gets
* @return
*/
public Result[] gets(String tbName, Collection<byte[]> gets) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
return table.get(gets.stream().map(Get::new).collect(Collectors.toList()));
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_READ_EXCEPTION_CODE, e.getMessage()));
}
}
public void delete(String tbName, byte[] rowKey) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
table.delete(new Delete(rowKey));
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_DELETE_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 批量删除
*
* @param tbName
* @param rowKeys
* @return
*/
public void deletes(String tbName, Collection<byte[]> rowKeys) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
table.delete(rowKeys.stream().map(Delete::new).collect(Collectors.toList()));
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_DELETE_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 自增
* @param tbName
* @param columnFamily
* @param rowKey
* @param field
* @param amount
* @return
*/
public Long increment(String tbName, byte[] columnFamily, byte[] rowKey, String field, long amount) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
return table.incrementColumnValue(rowKey, columnFamily, Bytes.toBytes(field), amount);
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_INCREMENT_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 扫描
*
* @param tbName
* @param scan
* @param consumer
*/
public void scan(String tbName, Scan scan, Consumer<Result> consumer) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName));
ResultScanner resultScanner = table.getScanner(scan)) {
for (Result result : resultScanner) {
consumer.accept(result);
}
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_SCAN_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 执行 consumer 操作
* @param tbName
* @param consumer
*/
public void execute(String tbName, Consumer<Table> consumer) throws YppRunTimeException {
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
consumer.accept(table);
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_EXECUTE_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 保存
* @param tbName
* @param put
* @return
*/
public void put(String tbName, Put put) throws YppRunTimeException{
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
table.put(put);
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_PUT_EXCEPTION_CODE, e.getMessage()));
}
}
/**
* 批量保存
* @param tbName
* @param puts
* @return
*/
public void put(String tbName, List<Put> puts) throws YppRunTimeException{
try (Table table = connection.getTable(TableName.valueOf(tbName))) {
table.put(puts);
} catch (IOException e) {
throw new YppRunTimeException(Code.business(HBASE_PUT_EXCEPTION_CODE, e.getMessage()));
}
}
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/annotation/CommonExecutor.java | sona-common/src/main/java/cn/bixin/sona/common/annotation/CommonExecutor.java | package cn.bixin.sona.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author qinwei
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CommonExecutor {
/**
* 接口描述
*/
String desc() default "";
/**
* 是否打印参数日志
*/
boolean printParam() default false;
/**
* 是否打印返回日志
*/
boolean printResponse() default false;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/annotation/Description.java | sona-common/src/main/java/cn/bixin/sona/common/annotation/Description.java | package cn.bixin.sona.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author qinwei
*/
@Target({ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Description {
String value() default "";
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/spring/SpringApplicationContext.java | sona-common/src/main/java/cn/bixin/sona/common/spring/SpringApplicationContext.java | package cn.bixin.sona.common.spring;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author qinwei
*/
@Component
public class SpringApplicationContext implements ApplicationContextAware {
private static ApplicationContext applicationContext;
private static String[] activeProfiles;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringApplicationContext.applicationContext = applicationContext;
activeProfiles = applicationContext.getEnvironment().getActiveProfiles();
}
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
public static <T> T getBean(String name, Class<T> clazz) {
return applicationContext.getBean(name, clazz);
}
public static <T> Map<String, T> getBeansOfType(Class<T> type) {
return applicationContext.getBeansOfType(type);
}
public static String getActiveProfile() {
if (activeProfiles == null || activeProfiles.length == 0) {
return null;
}
return activeProfiles[0];
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/kafka/TraceProducerInterceptor.java | sona-common/src/main/java/cn/bixin/sona/common/kafka/TraceProducerInterceptor.java | package cn.bixin.sona.common.kafka;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.trace.TracerContext;
import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import java.nio.charset.StandardCharsets;
import java.util.Map;
/**
* @author qinwei
*/
public class TraceProducerInterceptor implements ProducerInterceptor<String, String> {
@Override
public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
record.headers().add(TracerContext.TRACER_TRACE_ID, TraceHelper.getTraceId().getBytes(StandardCharsets.UTF_8));
return record;
}
@Override
public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
}
@Override
public void close() {
}
@Override
public void configure(Map<String, ?> configs) {
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/kafka/TraceRecordInterceptor.java | sona-common/src/main/java/cn/bixin/sona/common/kafka/TraceRecordInterceptor.java | package cn.bixin.sona.common.kafka;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.trace.TracerContext;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.header.Header;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.kafka.annotation.KafkaListener;
import java.util.Arrays;
/**
* @author qinwei
*/
@Order
@Aspect
public class TraceRecordInterceptor {
@Around("@annotation(annotation)")
public Object intercept(ProceedingJoinPoint pjp, KafkaListener annotation) throws Throwable {
ConsumerRecord consumerRecord = Arrays.stream(pjp.getArgs())
.filter(ConsumerRecord.class::isInstance)
.findFirst()
.map(ConsumerRecord.class::cast).orElseGet(null);
if (consumerRecord == null) {
return pjp.proceed();
}
Header header = consumerRecord.headers().lastHeader(TracerContext.TRACER_TRACE_ID);
if (header != null) {
TraceHelper.setTraceId(new String(header.value()));
} else {
TraceHelper.init();
}
try {
return pjp.proceed();
} finally {
TraceHelper.reset();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/enums/Product.java | sona-common/src/main/java/cn/bixin/sona/common/enums/Product.java | package cn.bixin.sona.common.enums;
import org.apache.commons.lang.StringUtils;
public enum Product {
TEST_PRODUCT("test");
private final String code;
Product(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public static Product getByCode(String code) {
if (StringUtils.isBlank(code)) {
return null;
}
for (Product each : Product.values()) {
if (each.getCode().equalsIgnoreCase(code)) {
return each;
}
}
return null;
}
public static Product getPlatformByName(String productCode) {
if (StringUtils.isBlank(productCode)) {
return null;
}
for (Product each : Product.values()) {
if (each.name().equalsIgnoreCase(productCode)) {
return each;
}
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/enums/RoomStatus.java | sona-common/src/main/java/cn/bixin/sona/common/enums/RoomStatus.java | package cn.bixin.sona.common.enums;
public enum RoomStatus {
INVALID(0),
VALID(1);
private final int code;
RoomStatus(int code) {
this.code = code;
}
public int getCode() {
return code;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-common/src/main/java/cn/bixin/sona/common/enums/PullMode.java | sona-common/src/main/java/cn/bixin/sona/common/enums/PullMode.java | package cn.bixin.sona.common.enums;
public enum PullMode {
SINGLE,
MULTI,
MIXED;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
jankovicsandras/imagetracerjava | https://github.com/jankovicsandras/imagetracerjava/blob/135f00e5e6383728e3063cfc39796073f68970b0/jankovicsandras/imagetracer/ImageTracer.java | jankovicsandras/imagetracer/ImageTracer.java | /*
ImageTracer.java
(Desktop version with javax.imageio. See ImageTracerAndroid.java for the Android version.)
Simple raster image tracer and vectorizer written in Java. This is a port of imagetracer.js.
by András Jankovics 2015, 2016
andras@jankovics.net
*/
/*
The Unlicense / PUBLIC DOMAIN
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
For more information, please refer to http://unlicense.org/
*/
package jankovicsandras.imagetracer;
import java.awt.image.BufferedImage;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeMap;
import javax.imageio.ImageIO;
public class ImageTracer{
public static String versionnumber = "1.1.2";
public ImageTracer(){}
public static void main (String[] args){
try{
if(args.length<1){
System.out.println("ERROR: there's no input filename. Basic usage: \r\n\r\njava -jar ImageTracer.jar <filename>"+
"\r\n\r\nor\r\n\r\njava -jar ImageTracer.jar help");
} else if(arraycontains(args,"help")>-1){
System.out.println("Example usage:\r\n\r\njava -jar ImageTracer.jar <filename> outfilename test.svg "+
"ltres 1 qtres 1 pathomit 8 colorsampling 1 numberofcolors 16 mincolorratio 0.02 colorquantcycles 3 "+
"scale 1 simplifytolerance 0 roundcoords 1 lcpr 0 qcpr 0 desc 1 viewbox 0 blurradius 0 blurdelta 20 \r\n"+
"\r\nOnly <filename> is mandatory, if some of the other optional parameters are missing, they will be set to these defaults. "+
"\r\nWarning: if outfilename is not specified, then <filename>.svg will be overwritten."+
"\r\nSee https://github.com/jankovicsandras/imagetracerjava for details. \r\nThis is version "+versionnumber);
} else {
// Parameter parsing
String outfilename = args[0]+".svg";
HashMap<String,Float> options = new HashMap<String,Float>();
String[] parameternames = {"ltres","qtres","pathomit","colorsampling","numberofcolors","mincolorratio","colorquantcycles","scale","simplifytolerance","roundcoords","lcpr","qcpr","desc","viewbox","blurradius","blurdelta","outfilename"};
int j = -1; float f = -1;
for (String parametername : parameternames) {
j = arraycontains(args,parametername);
if(j>-1){
if(parametername=="outfilename"){
if( j < (args.length-1)){ outfilename = args[j+1]; }
}else{
f = parsenext(args,j); if(f>-1){ options.put(parametername, new Float(f)); }
}
}
}// End of parameternames loop
// Loading image, tracing, rendering SVG, saving SVG file
saveString(outfilename,imageToSVG(args[0],options,null));
}// End of parameter parsing and processing
}catch(Exception e){ e.printStackTrace(); }
}// End of main()
public static int arraycontains (String [] arr, String str){
for(int j=0; j<arr.length; j++ ){ if(arr[j].toLowerCase().equals(str)){ return j; } } return -1;
}
public static float parsenext (String [] arr, int i){
if(i<(arr.length-1)){ try{ return Float.parseFloat(arr[i+1]); }catch(Exception e){} } return -1;
}
// Container for the color-indexed image before and tracedata after vectorizing
public static class IndexedImage{
public int width, height;
public int [][] array; // array[x][y] of palette colors
public byte [][] palette;// array[palettelength][4] RGBA color palette
public ArrayList<ArrayList<ArrayList<Double[]>>> layers;// tracedata
public IndexedImage(int [][] marray, byte [][] mpalette){
array = marray; palette = mpalette;
width = marray[0].length-2; height = marray.length-2;// Color quantization adds +2 to the original width and height
}
}
// https://developer.mozilla.org/en-US/docs/Web/API/ImageData
public static class ImageData{
public int width, height;
public byte[] data; // raw byte data: R G B A R G B A ...
public ImageData(int mwidth, int mheight, byte[] mdata){
width = mwidth; height = mheight; data = mdata;
}
}
// Saving a String as a file
public static void saveString (String filename, String str) throws Exception {
File file = new File(filename);
// if file doesnt exists, then create it
if(!file.exists()){ file.createNewFile(); }
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(str);
bw.close();
}
// Loading a file to ImageData, ARGB byte order
public static ImageData loadImageData (String filename) throws Exception {
BufferedImage image = ImageIO.read(new File(filename));
return loadImageData(image);
}
public static ImageData loadImageData (BufferedImage image) throws Exception {
int width = image.getWidth(); int height = image.getHeight();
int[] rawdata = image.getRGB(0, 0, width, height, null, 0, width);
byte[] data = new byte[rawdata.length*4];
for(int i=0; i<rawdata.length; i++){
data[(i*4)+3] = bytetrans((byte)(rawdata[i] >>> 24));
data[i*4 ] = bytetrans((byte)(rawdata[i] >>> 16));
data[(i*4)+1] = bytetrans((byte)(rawdata[i] >>> 8));
data[(i*4)+2] = bytetrans((byte)(rawdata[i]));
}
return new ImageData(width,height,data);
}
// The bitshift method in loadImageData creates signed bytes where -1 -> 255 unsigned ; -128 -> 128 unsigned ;
// 127 -> 127 unsigned ; 0 -> 0 unsigned ; These will be converted to -128 (representing 0 unsigned) ...
// 127 (representing 255 unsigned) and tosvgcolorstr will add +128 to create RGB values 0..255
public static byte bytetrans (byte b){
if(b<0){ return (byte)(b+128); }else{ return (byte)(b-128); }
}
////////////////////////////////////////////////////////////
//
// User friendly functions
//
////////////////////////////////////////////////////////////
// Loading an image from a file, tracing when loaded, then returning the SVG String
public static String imageToSVG (String filename, HashMap<String,Float> options, byte [][] palette) throws Exception{
options = checkoptions(options);
ImageData imgd = loadImageData(filename);
return imagedataToSVG(imgd,options,palette);
}// End of imageToSVG()
public static String imageToSVG (BufferedImage image, HashMap<String,Float> options, byte [][] palette) throws Exception{
options = checkoptions(options);
ImageData imgd = loadImageData(image);
return imagedataToSVG(imgd,options,palette);
}// End of imageToSVG()
// Tracing ImageData, then returning the SVG String
public static String imagedataToSVG (ImageData imgd, HashMap<String,Float> options, byte [][] palette){
options = checkoptions(options);
IndexedImage ii = imagedataToTracedata(imgd,options,palette);
return getsvgstring(ii, options);
}// End of imagedataToSVG()
// Loading an image from a file, tracing when loaded, then returning IndexedImage with tracedata in layers
public IndexedImage imageToTracedata (String filename, HashMap<String,Float> options, byte [][] palette) throws Exception{
options = checkoptions(options);
ImageData imgd = loadImageData(filename);
return imagedataToTracedata(imgd,options,palette);
}// End of imageToTracedata()
public IndexedImage imageToTracedata (BufferedImage image, HashMap<String,Float> options, byte [][] palette) throws Exception{
options = checkoptions(options);
ImageData imgd = loadImageData(image);
return imagedataToTracedata(imgd,options,palette);
}// End of imageToTracedata()
// Tracing ImageData, then returning IndexedImage with tracedata in layers
public static IndexedImage imagedataToTracedata (ImageData imgd, HashMap<String,Float> options, byte [][] palette){
// 1. Color quantization
IndexedImage ii = colorquantization(imgd, palette, options);
// 2. Layer separation and edge detection
int[][][] rawlayers = layering(ii);
// 3. Batch pathscan
ArrayList<ArrayList<ArrayList<Integer[]>>> bps = batchpathscan(rawlayers,(int)(Math.floor(options.get("pathomit"))));
// 4. Batch interpollation
ArrayList<ArrayList<ArrayList<Double[]>>> bis = batchinternodes(bps);
// 5. Batch tracing
ii.layers = batchtracelayers(bis,options.get("ltres"),options.get("qtres"));
return ii;
}// End of imagedataToTracedata()
// creating options object, setting defaults for missing values
public static HashMap<String,Float> checkoptions (HashMap<String,Float> options){
if(options==null){ options = new HashMap<String,Float>(); }
// Tracing
if(!options.containsKey("ltres")){ options.put("ltres",1f); }
if(!options.containsKey("qtres")){ options.put("qtres",1f); }
if(!options.containsKey("pathomit")){ options.put("pathomit",8f); }
// Color quantization
if(!options.containsKey("colorsampling")){ options.put("colorsampling",1f); }
if(!options.containsKey("numberofcolors")){ options.put("numberofcolors",16f); }
if(!options.containsKey("mincolorratio")){ options.put("mincolorratio",0.02f); }
if(!options.containsKey("colorquantcycles")){ options.put("colorquantcycles",3f); }
// SVG rendering
if(!options.containsKey("scale")){ options.put("scale",1f); }
if(!options.containsKey("simplifytolerance")){ options.put("simplifytolerance",0f); }
if(!options.containsKey("roundcoords")){ options.put("roundcoords",1f); }
if(!options.containsKey("lcpr")){ options.put("lcpr",0f); }
if(!options.containsKey("qcpr")){ options.put("qcpr",0f); }
if(!options.containsKey("desc")){ options.put("desc",1f); }
if(!options.containsKey("viewbox")){ options.put("viewbox",0f); }
// Blur
if(!options.containsKey("blurradius")){ options.put("blurradius",0f); }
if(!options.containsKey("blurdelta")){ options.put("blurdelta",20f); }
return options;
}// End of checkoptions()
////////////////////////////////////////////////////////////
//
// Vectorizing functions
//
////////////////////////////////////////////////////////////
// 1. Color quantization repeated "cycles" times, based on K-means clustering
// https://en.wikipedia.org/wiki/Color_quantization https://en.wikipedia.org/wiki/K-means_clustering
public static IndexedImage colorquantization (ImageData imgd, byte [][] palette, HashMap<String,Float> options){
int numberofcolors = (int)Math.floor(options.get("numberofcolors")); float minratio = options.get("mincolorratio"); int cycles = (int)Math.floor(options.get("colorquantcycles"));
// Creating indexed color array arr which has a boundary filled with -1 in every direction
int [][] arr = new int[imgd.height+2][imgd.width+2];
for(int j=0; j<(imgd.height+2); j++){ arr[j][0] = -1; arr[j][imgd.width+1 ] = -1; }
for(int i=0; i<(imgd.width+2) ; i++){ arr[0][i] = -1; arr[imgd.height+1][i] = -1; }
int idx=0, cd,cdl,ci,c1,c2,c3,c4;
// Use custom palette if pal is defined or sample or generate custom length palette
if(palette==null){
if(options.get("colorsampling")!=0){
palette = samplepalette(numberofcolors,imgd);
}else{
palette = generatepalette(numberofcolors);
}
}
// Selective Gaussian blur preprocessing
if( options.get("blurradius") > 0 ){ imgd = blur( imgd, options.get("blurradius"), options.get("blurdelta") ); }
long [][] paletteacc = new long[palette.length][5];
// Repeat clustering step "cycles" times
for(int cnt=0;cnt<cycles;cnt++){
// Average colors from the second iteration
if(cnt>0){
// averaging paletteacc for palette
float ratio;
for(int k=0;k<palette.length;k++){
// averaging
if(paletteacc[k][3]>0){
palette[k][0] = (byte) (-128 + (paletteacc[k][0] / paletteacc[k][4]));
palette[k][1] = (byte) (-128 + (paletteacc[k][1] / paletteacc[k][4]));
palette[k][2] = (byte) (-128 + (paletteacc[k][2] / paletteacc[k][4]));
palette[k][3] = (byte) (-128 + (paletteacc[k][3] / paletteacc[k][4]));
}
ratio = (float)( (double)(paletteacc[k][4]) / (double)(imgd.width*imgd.height) );
// Randomizing a color, if there are too few pixels and there will be a new cycle
if( (ratio<minratio) && (cnt<(cycles-1)) ){
palette[k][0] = (byte) (-128+Math.floor(Math.random()*255));
palette[k][1] = (byte) (-128+Math.floor(Math.random()*255));
palette[k][2] = (byte) (-128+Math.floor(Math.random()*255));
palette[k][3] = (byte) (-128+Math.floor(Math.random()*255));
}
}// End of palette loop
}// End of Average colors from the second iteration
// Reseting palette accumulator for averaging
for(int i=0;i<palette.length;i++){
paletteacc[i][0]=0;
paletteacc[i][1]=0;
paletteacc[i][2]=0;
paletteacc[i][3]=0;
paletteacc[i][4]=0;
}
// loop through all pixels
for(int j=0;j<imgd.height;j++){
for(int i=0;i<imgd.width;i++){
idx = ((j*imgd.width)+i)*4;
// find closest color from palette by measuring (rectilinear) color distance between this pixel and all palette colors
cdl = 256+256+256+256; ci=0;
for(int k=0;k<palette.length;k++){
// In my experience, https://en.wikipedia.org/wiki/Rectilinear_distance works better than https://en.wikipedia.org/wiki/Euclidean_distance
c1 = Math.abs(palette[k][0]-imgd.data[idx]);
c2 = Math.abs(palette[k][1]-imgd.data[idx+1]);
c3 = Math.abs(palette[k][2]-imgd.data[idx+2]);
c4 = Math.abs(palette[k][3]-imgd.data[idx+3]);
cd = c1+c2+c3+(c4*4); // weighted alpha seems to help images with transparency
// Remember this color if this is the closest yet
if(cd<cdl){ cdl = cd; ci = k; }
}// End of palette loop
// add to palettacc
paletteacc[ci][0] += 128+imgd.data[idx];
paletteacc[ci][1] += 128+imgd.data[idx+1];
paletteacc[ci][2] += 128+imgd.data[idx+2];
paletteacc[ci][3] += 128+imgd.data[idx+3];
paletteacc[ci][4]++;
arr[j+1][i+1] = ci;
}// End of i loop
}// End of j loop
}// End of Repeat clustering step "cycles" times
return new IndexedImage(arr, palette);
}// End of colorquantization
// Generating a palette with numberofcolors, array[numberofcolors][4] where [i][0] = R ; [i][1] = G ; [i][2] = B ; [i][3] = A
public static byte[][] generatepalette (int numberofcolors){
byte [][] palette = new byte[numberofcolors][4];
if(numberofcolors<8){
// Grayscale
double graystep = 255.0/(double)(numberofcolors-1);
for(byte ccnt=0;ccnt<numberofcolors;ccnt++){
palette[ccnt][0] = (byte)(-128+Math.round(ccnt*graystep));
palette[ccnt][1] = (byte)(-128+Math.round(ccnt*graystep));
palette[ccnt][2] = (byte)(-128+Math.round(ccnt*graystep));
palette[ccnt][3] = (byte)127;
}
}else{
// RGB color cube
int colorqnum = (int) Math.floor(Math.pow(numberofcolors, 1.0/3.0)); // Number of points on each edge on the RGB color cube
int colorstep = (int) Math.floor(255/(colorqnum-1)); // distance between points
int ccnt = 0;
for(int rcnt=0;rcnt<colorqnum;rcnt++){
for(int gcnt=0;gcnt<colorqnum;gcnt++){
for(int bcnt=0;bcnt<colorqnum;bcnt++){
palette[ccnt][0] = (byte)(-128+(rcnt*colorstep));
palette[ccnt][1] = (byte)(-128+(gcnt*colorstep));
palette[ccnt][2] = (byte)(-128+(bcnt*colorstep));
palette[ccnt][3] = (byte)127;
ccnt++;
}// End of blue loop
}// End of green loop
}// End of red loop
// Rest is random
for(int rcnt=ccnt;rcnt<numberofcolors;rcnt++){
palette[ccnt][0] = (byte)(-128+Math.floor(Math.random()*255));
palette[ccnt][1] = (byte)(-128+Math.floor(Math.random()*255));
palette[ccnt][2] = (byte)(-128+Math.floor(Math.random()*255));
palette[ccnt][3] = (byte)(-128+Math.floor(Math.random()*255));
}
}// End of numberofcolors check
return palette;
};// End of generatepalette()
public static byte[][] samplepalette (int numberofcolors, ImageData imgd){
int idx=0; byte [][] palette = new byte[numberofcolors][4];
for(int i=0; i<numberofcolors; i++){
idx = (int) (Math.floor( (Math.random() * imgd.data.length) / 4 ) * 4);
palette[i][0] = imgd.data[idx ];
palette[i][1] = imgd.data[idx+1];
palette[i][2] = imgd.data[idx+2];
palette[i][3] = imgd.data[idx+3];
}
return palette;
}// End of samplepalette()
// 2. Layer separation and edge detection
// Edge node types ( ▓:light or 1; ░:dark or 0 )
// 12 ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓
// 48 ░░ ░░ ░░ ░░ ░▓ ░▓ ░▓ ░▓ ▓░ ▓░ ▓░ ▓░ ▓▓ ▓▓ ▓▓ ▓▓
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//
public static int[][][] layering (IndexedImage ii){
// Creating layers for each indexed color in arr
int val=0, aw = ii.array[0].length, ah = ii.array.length, n1,n2,n3,n4,n5,n6,n7,n8;
int[][][] layers = new int[ii.palette.length][ah][aw];
// Looping through all pixels and calculating edge node type
for(int j=1; j<(ah-1); j++){
for(int i=1; i<(aw-1); i++){
// This pixel's indexed color
val = ii.array[j][i];
// Are neighbor pixel colors the same?
n1 = ii.array[j-1][i-1]==val ? 1 : 0;
n2 = ii.array[j-1][i ]==val ? 1 : 0;
n3 = ii.array[j-1][i+1]==val ? 1 : 0;
n4 = ii.array[j ][i-1]==val ? 1 : 0;
n5 = ii.array[j ][i+1]==val ? 1 : 0;
n6 = ii.array[j+1][i-1]==val ? 1 : 0;
n7 = ii.array[j+1][i ]==val ? 1 : 0;
n8 = ii.array[j+1][i+1]==val ? 1 : 0;
// this pixel"s type and looking back on previous pixels
layers[val][j+1][i+1] = 1 + (n5 * 2) + (n8 * 4) + (n7 * 8) ;
if(n4==0){ layers[val][j+1][i ] = 0 + 2 + (n7 * 4) + (n6 * 8) ; }
if(n2==0){ layers[val][j ][i+1] = 0 + (n3*2) + (n5 * 4) + 8 ; }
if(n1==0){ layers[val][j ][i ] = 0 + (n2*2) + 4 + (n4 * 8) ; }
}// End of i loop
}// End of j loop
return layers;
}// End of layering()
// Lookup tables for pathscan
static byte [] pathscan_dir_lookup = {0,0,3,0, 1,0,3,0, 0,3,3,1, 0,3,0,0};
static boolean [] pathscan_holepath_lookup = {false,false,false,false, false,false,false,true, false,false,false,true, false,true,true,false };
// pathscan_combined_lookup[ arr[py][px] ][ dir ] = [nextarrpypx, nextdir, deltapx, deltapy];
static byte [][][] pathscan_combined_lookup = {
{{-1,-1,-1,-1}, {-1,-1,-1,-1}, {-1,-1,-1,-1}, {-1,-1,-1,-1}},// arr[py][px]==0 is invalid
{{ 0, 1, 0,-1}, {-1,-1,-1,-1}, {-1,-1,-1,-1}, { 0, 2,-1, 0}},
{{-1,-1,-1,-1}, {-1,-1,-1,-1}, { 0, 1, 0,-1}, { 0, 0, 1, 0}},
{{ 0, 0, 1, 0}, {-1,-1,-1,-1}, { 0, 2,-1, 0}, {-1,-1,-1,-1}},
{{-1,-1,-1,-1}, { 0, 0, 1, 0}, { 0, 3, 0, 1}, {-1,-1,-1,-1}},
{{13, 3, 0, 1}, {13, 2,-1, 0}, { 7, 1, 0,-1}, { 7, 0, 1, 0}},
{{-1,-1,-1,-1}, { 0, 1, 0,-1}, {-1,-1,-1,-1}, { 0, 3, 0, 1}},
{{ 0, 3, 0, 1}, { 0, 2,-1, 0}, {-1,-1,-1,-1}, {-1,-1,-1,-1}},
{{ 0, 3, 0, 1}, { 0, 2,-1, 0}, {-1,-1,-1,-1}, {-1,-1,-1,-1}},
{{-1,-1,-1,-1}, { 0, 1, 0,-1}, {-1,-1,-1,-1}, { 0, 3, 0, 1}},
{{11, 1, 0,-1}, {14, 0, 1, 0}, {14, 3, 0, 1}, {11, 2,-1, 0}},
{{-1,-1,-1,-1}, { 0, 0, 1, 0}, { 0, 3, 0, 1}, {-1,-1,-1,-1}},
{{ 0, 0, 1, 0}, {-1,-1,-1,-1}, { 0, 2,-1, 0}, {-1,-1,-1,-1}},
{{-1,-1,-1,-1}, {-1,-1,-1,-1}, { 0, 1, 0,-1}, { 0, 0, 1, 0}},
{{ 0, 1, 0,-1}, {-1,-1,-1,-1}, {-1,-1,-1,-1}, { 0, 2,-1, 0}},
{{-1,-1,-1,-1}, {-1,-1,-1,-1}, {-1,-1,-1,-1}, {-1,-1,-1,-1}}// arr[py][px]==15 is invalid
};
// 3. Walking through an edge node array, discarding edge node types 0 and 15 and creating paths from the rest.
// Walk directions (dir): 0 > ; 1 ^ ; 2 < ; 3 v
// Edge node types ( ▓:light or 1; ░:dark or 0 )
// ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓
// ░░ ░░ ░░ ░░ ░▓ ░▓ ░▓ ░▓ ▓░ ▓░ ▓░ ▓░ ▓▓ ▓▓ ▓▓ ▓▓
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//
public static ArrayList<ArrayList<Integer[]>> pathscan (int [][] arr,float pathomit){
ArrayList<ArrayList<Integer[]>> paths = new ArrayList<ArrayList<Integer[]>>();
ArrayList<Integer[]> thispath;
int px=0,py=0,w=arr[0].length,h=arr.length,dir=0;
boolean pathfinished=true, holepath = false;
byte[] lookuprow;
for(int j=0;j<h;j++){
for(int i=0;i<w;i++){
if((arr[j][i]!=0)&&(arr[j][i]!=15)){
// Init
px = i; py = j;
paths.add(new ArrayList<Integer[]>());
thispath = paths.get(paths.size()-1);
pathfinished = false;
// fill paths will be drawn, but hole paths are also required to remove unnecessary edge nodes
dir = pathscan_dir_lookup[ arr[py][px] ]; holepath = pathscan_holepath_lookup[ arr[py][px] ];
// Path points loop
while(!pathfinished){
// New path point
thispath.add(new Integer[3]);
thispath.get(thispath.size()-1)[0] = px-1;
thispath.get(thispath.size()-1)[1] = py-1;
thispath.get(thispath.size()-1)[2] = arr[py][px];
// Next: look up the replacement, direction and coordinate changes = clear this cell, turn if required, walk forward
lookuprow = pathscan_combined_lookup[ arr[py][px] ][ dir ];
arr[py][px] = lookuprow[0]; dir = lookuprow[1]; px += lookuprow[2]; py += lookuprow[3];
// Close path
if(((px-1)==thispath.get(0)[0])&&((py-1)==thispath.get(0)[1])){
pathfinished = true;
// Discarding 'hole' type paths and paths shorter than pathomit
if( (holepath) || (thispath.size()<pathomit) ){
paths.remove(thispath);
}
}
}// End of Path points loop
}// End of Follow path
}// End of i loop
}// End of j loop
return paths;
}// End of pathscan()
// 3. Batch pathscan
public static ArrayList<ArrayList<ArrayList<Integer[]>>> batchpathscan (int [][][] layers, float pathomit){
ArrayList<ArrayList<ArrayList<Integer[]>>> bpaths = new ArrayList<ArrayList<ArrayList<Integer[]>>>();
for (int[][] layer : layers) {
bpaths.add(pathscan(layer,pathomit));
}
return bpaths;
}
// 4. interpolating between path points for nodes with 8 directions ( East, SouthEast, S, SW, W, NW, N, NE )
public static ArrayList<ArrayList<Double[]>> internodes (ArrayList<ArrayList<Integer[]>> paths){
ArrayList<ArrayList<Double[]>> ins = new ArrayList<ArrayList<Double[]>>();
ArrayList<Double[]> thisinp;
Double[] thispoint, nextpoint = new Double[2];
Integer[] pp1, pp2, pp3;
int palen=0,nextidx=0,nextidx2=0;
// paths loop
for(int pacnt=0; pacnt<paths.size(); pacnt++){
ins.add(new ArrayList<Double[]>());
thisinp = ins.get(ins.size()-1);
palen = paths.get(pacnt).size();
// pathpoints loop
for(int pcnt=0;pcnt<palen;pcnt++){
// interpolate between two path points
nextidx = (pcnt+1)%palen; nextidx2 = (pcnt+2)%palen;
thisinp.add(new Double[3]);
thispoint = thisinp.get(thisinp.size()-1);
pp1 = paths.get(pacnt).get(pcnt);
pp2 = paths.get(pacnt).get(nextidx);
pp3 = paths.get(pacnt).get(nextidx2);
thispoint[0] = (pp1[0]+pp2[0]) / 2.0;
thispoint[1] = (pp1[1]+pp2[1]) / 2.0;
nextpoint[0] = (pp2[0]+pp3[0]) / 2.0;
nextpoint[1] = (pp2[1]+pp3[1]) / 2.0;
// line segment direction to the next point
if(thispoint[0] < nextpoint[0]){
if (thispoint[1] < nextpoint[1]){ thispoint[2] = 1.0; }// SouthEast
else if(thispoint[1] > nextpoint[1]){ thispoint[2] = 7.0; }// NE
else { thispoint[2] = 0.0; } // E
}else if(thispoint[0] > nextpoint[0]){
if (thispoint[1] < nextpoint[1]){ thispoint[2] = 3.0; }// SW
else if(thispoint[1] > nextpoint[1]){ thispoint[2] = 5.0; }// NW
else { thispoint[2] = 4.0; }// W
}else{
if (thispoint[1] < nextpoint[1]){ thispoint[2] = 2.0; }// S
else if(thispoint[1] > nextpoint[1]){ thispoint[2] = 6.0; }// N
else { thispoint[2] = 8.0; }// center, this should not happen
}
}// End of pathpoints loop
}// End of paths loop
return ins;
}// End of internodes()
// 4. Batch interpollation
static ArrayList<ArrayList<ArrayList<Double[]>>> batchinternodes (ArrayList<ArrayList<ArrayList<Integer[]>>> bpaths){
ArrayList<ArrayList<ArrayList<Double[]>>> binternodes = new ArrayList<ArrayList<ArrayList<Double[]>>>();
for(int k=0; k<bpaths.size(); k++) {
binternodes.add(internodes(bpaths.get(k)));
}
return binternodes;
}
// 5. tracepath() : recursively trying to fit straight and quadratic spline segments on the 8 direction internode path
// 5.1. Find sequences of points with only 2 segment types
// 5.2. Fit a straight line on the sequence
// 5.3. If the straight line fails (an error>ltreshold), find the point with the biggest error
// 5.4. Fit a quadratic spline through errorpoint (project this to get controlpoint), then measure errors on every point in the sequence
// 5.5. If the spline fails (an error>qtreshold), find the point with the biggest error, set splitpoint = (fitting point + errorpoint)/2
// 5.6. Split sequence and recursively apply 5.2. - 5.7. to startpoint-splitpoint and splitpoint-endpoint sequences
// 5.7. TODO? If splitpoint-endpoint is a spline, try to add new points from the next sequence
// This returns an SVG Path segment as a double[7] where
// segment[0] ==1.0 linear ==2.0 quadratic interpolation
// segment[1] , segment[2] : x1 , y1
// segment[3] , segment[4] : x2 , y2 ; middle point of Q curve, endpoint of L line
// segment[5] , segment[6] : x3 , y3 for Q curve, should be 0.0 , 0.0 for L line
//
// path type is discarded, no check for path.size < 3 , which should not happen
public static ArrayList<Double[]> tracepath (ArrayList<Double[]> path, float ltreshold, float qtreshold){
int pcnt=0, seqend=0; double segtype1, segtype2;
ArrayList<Double[]> smp = new ArrayList<Double[]>();
//Double [] thissegment;
int pathlength = path.size();
while(pcnt<pathlength){
// 5.1. Find sequences of points with only 2 segment types
segtype1 = path.get(pcnt)[2]; segtype2 = -1; seqend=pcnt+1;
while(
((path.get(seqend)[2]==segtype1) || (path.get(seqend)[2]==segtype2) || (segtype2==-1))
&& (seqend<(pathlength-1))){
if((path.get(seqend)[2]!=segtype1) && (segtype2==-1)){ segtype2 = path.get(seqend)[2];}
seqend++;
}
if(seqend==(pathlength-1)){ seqend = 0; }
// 5.2. - 5.6. Split sequence and recursively apply 5.2. - 5.6. to startpoint-splitpoint and splitpoint-endpoint sequences
smp.addAll(fitseq(path,ltreshold,qtreshold,pcnt,seqend));
// 5.7. TODO? If splitpoint-endpoint is a spline, try to add new points from the next sequence
// forward pcnt;
if(seqend>0){ pcnt = seqend; }else{ pcnt = pathlength; }
}// End of pcnt loop
return smp;
}// End of tracepath()
// 5.2. - 5.6. recursively fitting a straight or quadratic line segment on this sequence of path nodes,
// called from tracepath()
public static ArrayList<Double[]> fitseq (ArrayList<Double[]> path, float ltreshold, float qtreshold, int seqstart, int seqend){
ArrayList<Double[]> segment = new ArrayList<Double[]>();
Double [] thissegment;
int pathlength = path.size();
// return if invalid seqend
if((seqend>pathlength)||(seqend<0)){return segment;}
int errorpoint=seqstart;
boolean curvepass=true;
double px, py, dist2, errorval=0;
double tl = (seqend-seqstart); if(tl<0){ tl += pathlength; }
double vx = (path.get(seqend)[0]-path.get(seqstart)[0]) / tl,
vy = (path.get(seqend)[1]-path.get(seqstart)[1]) / tl;
// 5.2. Fit a straight line on the sequence
int pcnt = (seqstart+1)%pathlength;
double pl;
while(pcnt != seqend){
pl = pcnt-seqstart; if(pl<0){ pl += pathlength; }
px = path.get(seqstart)[0] + (vx * pl); py = path.get(seqstart)[1] + (vy * pl);
dist2 = ((path.get(pcnt)[0]-px)*(path.get(pcnt)[0]-px)) + ((path.get(pcnt)[1]-py)*(path.get(pcnt)[1]-py));
if(dist2>ltreshold){curvepass=false;}
if(dist2>errorval){ errorpoint=pcnt; errorval=dist2; }
pcnt = (pcnt+1)%pathlength;
}
// return straight line if fits
if(curvepass){
segment.add(new Double[7]);
thissegment = segment.get(segment.size()-1);
thissegment[0] = 1.0;
thissegment[1] = path.get(seqstart)[0];
thissegment[2] = path.get(seqstart)[1];
thissegment[3] = path.get(seqend)[0];
thissegment[4] = path.get(seqend)[1];
thissegment[5] = 0.0;
thissegment[6] = 0.0;
return segment;
}
// 5.3. If the straight line fails (an error>ltreshold), find the point with the biggest error
int fitpoint = errorpoint; curvepass = true; errorval = 0;
// 5.4. Fit a quadratic spline through this point, measure errors on every point in the sequence
// helpers and projecting to get control point
double t=(fitpoint-seqstart)/tl, t1=(1.0-t)*(1.0-t), t2=2.0*(1.0-t)*t, t3=t*t;
double cpx = (((t1*path.get(seqstart)[0]) + (t3*path.get(seqend)[0])) - path.get(fitpoint)[0])/-t2 ,
cpy = (((t1*path.get(seqstart)[1]) + (t3*path.get(seqend)[1])) - path.get(fitpoint)[1])/-t2 ;
// Check every point
pcnt = seqstart+1;
while(pcnt != seqend){
t=(pcnt-seqstart)/tl; t1=(1.0-t)*(1.0-t); t2=2.0*(1.0-t)*t; t3=t*t;
px = (t1 * path.get(seqstart)[0]) + (t2 * cpx) + (t3 * path.get(seqend)[0]);
py = (t1 * path.get(seqstart)[1]) + (t2 * cpy) + (t3 * path.get(seqend)[1]);
dist2 = ((path.get(pcnt)[0]-px)*(path.get(pcnt)[0]-px)) + ((path.get(pcnt)[1]-py)*(path.get(pcnt)[1]-py));
if(dist2>qtreshold){curvepass=false;}
if(dist2>errorval){ errorpoint=pcnt; errorval=dist2; }
pcnt = (pcnt+1)%pathlength;
}
// return spline if fits
if(curvepass){
segment.add(new Double[7]);
thissegment = segment.get(segment.size()-1);
thissegment[0] = 2.0;
thissegment[1] = path.get(seqstart)[0];
thissegment[2] = path.get(seqstart)[1];
thissegment[3] = cpx;
thissegment[4] = cpy;
thissegment[5] = path.get(seqend)[0];
thissegment[6] = path.get(seqend)[1];
return segment;
}
// 5.5. If the spline fails (an error>qtreshold), find the point with the biggest error,
// set splitpoint = (fitting point + errorpoint)/2
int splitpoint = (fitpoint + errorpoint)/2;
// 5.6. Split sequence and recursively apply 5.2. - 5.6. to startpoint-splitpoint and splitpoint-endpoint sequences
segment = fitseq(path,ltreshold,qtreshold,seqstart,splitpoint);
segment.addAll(fitseq(path,ltreshold,qtreshold,splitpoint,seqend));
return segment;
}// End of fitseq()
// 5. Batch tracing paths
public static ArrayList<ArrayList<Double[]>> batchtracepaths (ArrayList<ArrayList<Double[]>> internodepaths, float ltres,float qtres){
ArrayList<ArrayList<Double[]>> btracedpaths = new ArrayList<ArrayList<Double[]>>();
for(int k=0; k<internodepaths.size(); k++){
btracedpaths.add(tracepath(internodepaths.get(k),ltres,qtres) );
}
return btracedpaths;
}
// 5. Batch tracing layers
public static ArrayList<ArrayList<ArrayList<Double[]>>> batchtracelayers (ArrayList<ArrayList<ArrayList<Double[]>>> binternodes, float ltres, float qtres){
ArrayList<ArrayList<ArrayList<Double[]>>> btbis = new ArrayList<ArrayList<ArrayList<Double[]>>>();
for(int k=0; k<binternodes.size(); k++){
btbis.add( batchtracepaths( binternodes.get(k),ltres,qtres) );
}
return btbis;
}
////////////////////////////////////////////////////////////
//
// SVG Drawing functions
//
////////////////////////////////////////////////////////////
public static float roundtodec (float val, float places){
return (float)(Math.round(val*Math.pow(10,places))/Math.pow(10,places));
}
// Getting SVG path element string from a traced path
public static void svgpathstring (StringBuilder sb, String desc, ArrayList<Double[]> segments, String colorstr, HashMap<String,Float> options){
| java | Unlicense | 135f00e5e6383728e3063cfc39796073f68970b0 | 2026-01-05T02:40:31.856645Z | true |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/helloworld/src/main/java/io/manbang/helloworld/HelloWorld.java | helloworld/src/main/java/io/manbang/helloworld/HelloWorld.java | package io.manbang.helloworld;
/**
* @author xujie
*/
public class HelloWorld {
public static void main(String[] args) throws InterruptedException {
new HelloWorld().loop(null);
}
void loop(UserModel userModel) throws InterruptedException {
while (true) {
runPrint(userModel);
}
}
void runPrint(UserModel userModel) throws InterruptedException {
try {
System.out.println(userModel.getName());
} catch (Throwable cause) {
cause.printStackTrace();
}
Thread.sleep(1000);
}
public static class UserModel {
String name;
int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/EasyByteCoderClassFileTransformer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/EasyByteCoderClassFileTransformer.java | package io.manbang.easybytecoder.traffichandler;
import java.lang.instrument.ClassFileTransformer;
/**
* @author GaoYang 2018/12/13
*/
public interface EasyByteCoderClassFileTransformer extends ClassFileTransformer {
/**
* 获取plugin Jar包文件路径
*
* @return
*/
String getRelatedJarFilePath();
/**
* 设置plugin Jar包文件路径
*
* @return
*/
void setRelatedJarFilePath(String jarFilePath);
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/DoTransformer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/DoTransformer.java | package io.manbang.easybytecoder.traffichandler;
import io.manbang.easybytecoder.traffichandler.modifier.CatchCode;
import io.manbang.easybytecoder.traffichandler.modifier.ClassModifier;
import io.manbang.easybytecoder.traffichandler.modifier.MethodModifyCode;
import javassist.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
/**
* @author xujie
* 修改类字节码的具体执行方法
*/
public enum DoTransformer {
/**
* 单例的DoTransformer实例
*/
INSTANCE;
private static final Logger logger = LoggerFactory.getLogger(DoTransformer.class);
private String debugDump = "./dump";
/**
* 修改类方法
*
* @param className
* @param modifier
* @param cp
* @param ctClass
* @return
*/
public byte[] execute(String className, ClassModifier modifier, ClassPool cp, CtClass ctClass) throws Exception {
try {
// enbale when need debug
CtClass.debugDump = debugDump;
List<CtField> fieldsToAdd = modifier.getFieldsToAdd(ctClass, cp);
if (null != fieldsToAdd) {
for (CtField f : fieldsToAdd) {
ctClass.addField(f);
}
}
CtMethod[] declaredMethods = ctClass.getDeclaredMethods();
CtConstructor[] constructors = ctClass.getConstructors();
//支持构造函数修改
constructorsModifier(modifier, ctClass, constructors);
//方法级别的修改
for (CtMethod method : declaredMethods) {
MethodModifyCode methodModifier = modifier.getMethodModifier(method.getName());
if (methodModifier == null) {
logger.warn("skip method because methodModifier is null method:{}", method.getName());
continue;
}
// 如果需要进行参数匹配，则进行参数匹配
if (methodModifier.ifNeedCheckParam() && checkParam(cp, method, methodModifier)) {
continue;
}
//对body的修改
if (bodyModifier(ctClass, method, methodModifier)) {
continue;
}
//装载局部变量
localVariablesModifier(method, methodModifier);
//在方法运行之前插入相关代码
beforeModifier(method, methodModifier);
//在方法运行之后之前插入相关代码
afterModifier(method, methodModifier);
//捕获被修改方法的异常
tryCatchEncircleModifier(method, methodModifier);
logger.info("find transform method end [{}#{}({})] .", className, method.getName(), assembleMethodParams(method.getParameterTypes()));
}
} catch (Throwable e) {
logger.error("doTransform className:{} err:", className, e);
}
return ctClass.toBytecode();
}
/**
* 对方法使用try Catch包围
*
* @param method
* @param methodModifier
*/
private void tryCatchEncircleModifier(CtMethod method, MethodModifyCode methodModifier) {
CatchCode catchCode = methodModifier.getCatchCode();
if (catchCode != null) {
try {
CtClass retype = catchCode.getCatchType();
if (retype == null) {
retype = ClassPool.getDefault().get("java.lang.Exception");
}
method.addCatch(catchCode.getCodes(), retype);
} catch (Exception e) {
logger.error("addCatch ERROR:{}, code:{}", e, catchCode);
}
}
}
/**
* 在原代码方法之后加入代码
*
* @param method
* @param methodModifier
*/
private void afterModifier(CtMethod method, MethodModifyCode methodModifier) {
if (methodModifier.getCodeInsertAfter() == null) {
return;
}
for (String afterCode : methodModifier.getCodeInsertAfter()) {
try {
method.insertAfter(afterCode);
} catch (Exception e) {
logger.error("afterCode ERROR: {}, code:{}", e, afterCode);
}
}
}
/**
* 在原代码方法之前加入代码
*
* @param method
* @param methodModifier
*/
private void beforeModifier(CtMethod method, MethodModifyCode methodModifier) {
if (methodModifier.getCodeInsertBefore() == null) {
return;
}
List<String> codeToInsertBefore = methodModifier.getCodeInsertBefore();
Collections.reverse(codeToInsertBefore);
for (String beforeCode : codeToInsertBefore) {
try {
method.insertBefore(beforeCode);
} catch (Exception e) {
logger.error("insertBefore ERROR: {}, code:{}", e, beforeCode);
}
}
}
/**
* 在方法中加入局部变量
*
* @param method
* @param methodModifier
*/
private void localVariablesModifier(CtMethod method, MethodModifyCode methodModifier) {
if (methodModifier.localVariables() == null || methodModifier.localVariables().size() == 0) {
return;
}
for (Map.Entry<String, CtClass> stringCtClassEntry : methodModifier.localVariables().entrySet()) {
try {
method.addLocalVariable(stringCtClassEntry.getKey(), stringCtClassEntry.getValue());
} catch (Exception e) {
logger.error("addLocalVariable key:{} value:{}", stringCtClassEntry.getKey(), stringCtClassEntry.getValue(), e);
}
}
}
/**
* 替换整个方法体
*
* @param ctClass
* @param method
* @param methodModifier
* @return
* @throws NotFoundException
*/
private boolean bodyModifier(CtClass ctClass, CtMethod method, MethodModifyCode methodModifier) throws NotFoundException {
if (!methodModifier.getCodeToSetBody(method).isEmpty()) {
logger.info("find transform method body [{}#{}({})].", ctClass.getName(), method.getName(), assembleMethodParams(method.getParameterTypes()));
try {
method.setBody(methodModifier.getCodeToSetBody(method));
} catch (Exception e) {
logger.error("setBody ERROR:{}, code:{}", e, methodModifier.getCodeToSetBody(method));
}
if (!method.getName().equals("registerClients")) {
insertTryCode(method);
}
return true;
}
return false;
}
/**
* 检查参数映射，找到符合入参定义的方法
*
* @param cp
* @param method
* @param methodModifier
* @return
* @throws NotFoundException
*/
private boolean checkParam(ClassPool cp, CtMethod method, MethodModifyCode methodModifier) throws NotFoundException {
if (methodModifier.ifNeedCheckParamByOwn() && !methodModifier.checkParamByOwn(method.getParameterTypes(), cp)) {
return true;
} else {
CtClass[] paramsNeed = methodModifier.getToModifyMethodParamDecl(cp);
if (!Objects.deepEquals(paramsNeed, method.getParameterTypes())) {
logger.trace("skip method for params diff: {}", method.getName());
return true;
}
}
return false;
}
/**
* 对构造方法的修改
*
* @param modifier
* @param ctClass
* @param constructors
* @throws NotFoundException
*/
private void constructorsModifier(ClassModifier modifier, CtClass ctClass, CtConstructor[] constructors) throws NotFoundException {
for (CtConstructor ctConstructor : constructors) {
MethodModifyCode methodModifier = modifier.getMethodModifier(ctConstructor.getName());
//如果修改的是构造函数，
if (methodModifier != null) {
logger.info("find transform constructor body [{}#{}({})].", ctClass.getName(), ctConstructor.getName(), assembleMethodParams(ctConstructor.getParameterTypes()));
try {
ctConstructor.setBody(methodModifier.getCodeToSetBody(ctConstructor));
} catch (Exception e) {
logger.error("setBody ERROR:{}, code:{}", e, methodModifier.getCodeToSetBody(ctConstructor));
}
insertTryCode(ctConstructor);
}
}
}
/**
* 组装方法的参数
*
* @param params
* @return param1, param2, param3
*/
private String assembleMethodParams(CtClass[] params) {
if (params == null) {
return "";
}
List<String> ps = new ArrayList<>(params.length);
for (CtClass p : params) {
ps.add(p.getName());
}
return org.apache.commons.lang3.StringUtils.join(ps, ",");
}
/**
* 增加默认的tryCatc
*
* @param method
*/
private void insertTryCode(CtBehavior method) {
if (method.getMethodInfo().getCodeAttribute() == null) {
return;
}
try {
CtClass etype = ClassPool.getDefault().get("java.lang.Exception");
method.addCatch("{ EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error(\"invoke method Failed!, error:\",$e); throw $e; }", etype);
} catch (Exception e) {
logger.error("insertTryCode error:", e);
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/BaseTransformer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/BaseTransformer.java | package io.manbang.easybytecoder.traffichandler;
import io.manbang.easybytecoder.traffichandler.modifier.ClassModifier;
import io.manbang.easybytecoder.traffichandler.utils.StringUtils;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.LoaderClassPath;
import javassist.NotFoundException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.ProtectionDomain;
import java.util.*;
/**
* @author GaoYang 2018/12/10
*/
public abstract class BaseTransformer implements EasyByteCoderClassFileTransformer {
private static final Logger logger = LoggerFactory.getLogger(BaseTransformer.class);
/**
* @key: classname 待修改的类名
* @value: modifier 类修改器
*/
protected Map<String, ClassModifier> classModifiers = new HashMap<>();
/**
* @key: interfaceClass 待修改的接口类名，所有该接口的实现类都会被修改
* @value: modifier 类修改器
*/
protected Map<String, ClassModifier> interfaceImplClassModifiers = new HashMap<>();
public BaseTransformer() {
}
/**
* 每个plugin 的初始化方法
*
* @return
*/
public abstract boolean init();
/**
* 所有需要加载的类
* @return
*/
public List<String> getClassNameList() {
List<String> list = new ArrayList<>();
for (Map.Entry<String, ClassModifier> stringClassModifierEntry : classModifiers.entrySet()) {
if(stringClassModifierEntry==null){
continue;
}
String className = stringClassModifierEntry.getKey().replace("/", ".");
list.add(className);
}
return list;
}
/**
* 获取plugin jar包文件路径
*
* @return String
*/
@Override
public abstract String getRelatedJarFilePath();
/**
* 设置plugin jar包文件路径
*
* @param jarFilePath
*/
@Override
public abstract void setRelatedJarFilePath(String jarFilePath);
/**
* instrument 技术核心方法： 所有被jvm加载的类，都会调用已注册的transformer，进行类方法的修改拦截
*/
@Override
public byte[] transform(ClassLoader originLoader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
try {
// 1. 过滤无需处理的类
if (className == null) {
return classfileBuffer;
}
// 2. 检查是否定义此类的修改代码
ClassModifier modifier = findMatchedClassModifier(className);
ClassPool cp = new ClassPool(true);
cp.appendClassPath(new LoaderClassPath(originLoader));
CtClass currentCtClass = cp.makeClass(new ByteArrayInputStream(classfileBuffer));
if (modifier == null) {
String interfaceClassName = findInterfaceImplClassModifier(className, currentCtClass, cp);
modifier = interfaceImplClassModifiers.get(interfaceClassName);
}
if (modifier == null) {
return classfileBuffer;
}
// 3. 注入plugin jar包
importRelatedJar(originLoader);
// 4. 添加import 包声明
List<String> packagesToImport = modifier.getResourceToImport(originLoader);
for (String res : packagesToImport) {
cp.importPackage(res);
}
cp.importPackage("io.manbang.easybytecoder.runtimecommonapi.utils.EasyByteCoderResourceObjectPool");
cp.importPackage("io.manbang.easybytecoder.runtimecommonapi.utils.PluginContext");
// 5. 执行类修改
return DoTransformer.INSTANCE.execute(className, modifier, cp, currentCtClass);
} catch (Exception e) {
logger.error("transform className:{} error:", className, e);
}
return classfileBuffer;
}
/**
* 加载相关的jar文件
*
* @param originLoader
*/
private void importRelatedJar(ClassLoader originLoader) {
if (StringUtils.isNotEmpty(getRelatedJarFilePath())) {
try {
Method method = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
method.setAccessible(true);
File file = new File(getRelatedJarFilePath());
method.invoke(originLoader, new Object[]{file.toURI().normalize().toURL()});
} catch (Exception e) {
logger.error("loading relatedJarFile:{} error:", getRelatedJarFilePath(), e);
}
}
}
private ClassModifier findMatchedClassModifier(String className) {
// fast path
ClassModifier matchedClassModifier = classModifiers.get(className);
if (matchedClassModifier != null) {
return matchedClassModifier;
}
// slow path. may lose some performance.
// fix the shaded package problem. ie: com.google.protobuf.BlockingRpcChannel -> org.apache.hadoop.hbase.shaded.com.google.protobuf.BlockingRpcChannel
Iterator<Map.Entry<String, ClassModifier>> it = classModifiers.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, ClassModifier> entry = it.next();
// 规避entry.getKey()为空的情况
String targetClassName = entry.getKey();
if (targetClassName == null || targetClassName.isEmpty()) {
continue;
}
if (className.endsWith(targetClassName)) {
return entry.getValue();
}
}
return null;
}
private String findInterfaceImplClassModifier(String className, CtClass ctClass, ClassPool classPool) {
for (String interfaceClass : interfaceImplClassModifiers.keySet()) {
if (doCheckImplementCertainClass(interfaceClass, classPool, ctClass)) {
logger.info("Found implement of interface:" + interfaceClass + " ToModifyClassName:" + className);
return interfaceClass;
}
}
return null;
}
/**
* 检查当前类 是否是指定interface类的实现
*
* @param interfaceClass
* @param cp
* @param ctClass
* @return
*/
private boolean doCheckImplementCertainClass(String interfaceClass, ClassPool cp, CtClass ctClass) {
try {
if (!ctClass.isInterface()) {
CtClass interfaceCtClass = cp.get(interfaceClass);
return ctClass.subtypeOf(interfaceCtClass);
}
} catch (NotFoundException e) {
logger.error("doCheckImplementCertainClass Failed! NotFound:" + interfaceClass);
}
return false;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/AttachTrafficHandler.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/AttachTrafficHandler.java | package io.manbang.easybytecoder.traffichandler;
import java.lang.instrument.ClassFileTransformer;
import java.util.List;
import java.util.Map;
/**
* @author xujie
*/
public interface AttachTrafficHandler {
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/TrafficHandler.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/TrafficHandler.java | package io.manbang.easybytecoder.traffichandler;
import java.lang.instrument.ClassFileTransformer;
import java.util.Map;
public interface TrafficHandler {
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/TtlTransformer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/TtlTransformer.java | package io.manbang.easybytecoder.traffichandler;
import com.alibaba.ttl.threadpool.agent.internal.logging.Logger;
import com.alibaba.ttl.threadpool.agent.internal.transformlet.JavassistTransformlet;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
public class TtlTransformer implements ClassFileTransformer {
private static final Logger logger = Logger.getLogger(com.alibaba.ttl.threadpool.agent.TtlTransformer.class);
private static final byte[] EMPTY_BYTE_ARRAY = {};
private final List<JavassistTransformlet> transformletList = new ArrayList<JavassistTransformlet>();
TtlTransformer(List<? extends JavassistTransformlet> transformletList) {
for (JavassistTransformlet transformlet : transformletList) {
this.transformletList.add(transformlet);
logger.info("[TtlTransformer] add Transformlet " + transformlet.getClass() + " success");
}
}
@Override
public final byte[] transform( final ClassLoader loader, final String classFile, final Class<?> classBeingRedefined,
final ProtectionDomain protectionDomain, final byte[] classFileBuffer) {
try {
// Lambda has no class file, no need to transform, just return.
if (classFile == null) {
return classFileBuffer;
}
final String className = toClassName(classFile);
for (JavassistTransformlet transformlet : transformletList) {
final byte[] bytes = transformlet.doTransform(className, classFileBuffer, loader);
if (bytes != null) {
return bytes;
}
}
} catch (Throwable t) {
String msg = "Fail to transform class " + classFile + ", cause: " + t.toString();
logger.log(Level.SEVERE, msg, t);
throw new IllegalStateException(msg, t);
}
return classFileBuffer;
}
private static String toClassName(final String classFile) {
return classFile.replace('/', '.');
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/logger/EasyByteCoderClientLogger.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/logger/EasyByteCoderClientLogger.java | package io.manbang.easybytecoder.traffichandler.logger;
import io.manbang.easybytecoder.runtimecommonapi.log.EasyByteCoderLogger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author GaoYang 2018/12/23
*/
public class EasyByteCoderClientLogger implements EasyByteCoderLogger {
private static final Logger logger = LoggerFactory.getLogger(EasyByteCoderClientLogger.class);
@Override
public void debug(String var1) {
logger.debug(var1);
}
@Override
public void debug(String format, Object arg) {
logger.debug(format, arg);
}
@Override
public void debug(String format, Object arg1, Object arg2) {
logger.debug(format, arg1, arg2);
}
@Override
public void debug(String format, Object... arguments) {
logger.debug(format, arguments);
}
@Override
public void info(String var1) {
logger.info(var1);
}
@Override
public void warn(String var1) {
logger.warn(var1);
}
@Override
public void error(String var1) {
logger.error(var1);
}
@Override
public void error(String var1, Throwable e) {
logger.error(var1, e);
}
@Override
public void error(String format, Object... arguments) {
logger.error(format, arguments);
}
@Override
public void trace(String var1) {
logger.trace(var1);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/systemhandler/SystemTrafficHandler.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/systemhandler/SystemTrafficHandler.java | package io.manbang.easybytecoder.traffichandler.systemhandler;
import java.util.Map;
public interface SystemTrafficHandler {
boolean init(String jarFile, Map<String, String> args);
SystemClassTransformer getTransformer();
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/systemhandler/SystemClassTransformer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/systemhandler/SystemClassTransformer.java | package io.manbang.easybytecoder.traffichandler.systemhandler;
import io.manbang.easybytecoder.traffichandler.modifier.SystemClassModifier;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.LoaderClassPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;
import java.util.*;
/**
* 系统相关类的修改
*
* @Author: sundaoming
* @CreateDate: 2019/4/22 15:23
*/
public abstract class SystemClassTransformer implements ClassFileTransformer {
private static final Logger logger = LoggerFactory.getLogger(SystemClassTransformer.class);
public Map<String, SystemClassModifier> methodModifiers = new HashMap<>();
public abstract boolean init();
private ClassLoader doomClassLoader;
public Set<Class<?>> getListClass() {
Set<Class<?>> set = new HashSet<>();
for (Map.Entry<String, SystemClassModifier> stringSystemClassModifierEntry : methodModifiers.entrySet()) {
set.addAll(stringSystemClassModifierEntry.getValue().getRetransformClassList());
}
return set;
}
@Override
public byte[] transform(final ClassLoader originLoader, final String className, final Class<?> classBeingRedefined, final ProtectionDomain protectionDomain, final byte[] classFileBuffer) {
CtClass.debugDump = "./dump";
if (className == null) {
return classFileBuffer;
}
ClassPool cp = new ClassPool(true);
cp.appendClassPath(new LoaderClassPath(originLoader));
CtClass currentCtClass = null;
try {
currentCtClass = cp.makeClass(new ByteArrayInputStream(classFileBuffer));
} catch (Throwable e) {
logger.error("SystemClassTransformer makeClass error", e);
return classFileBuffer;
}
byte[] result = null;
SystemClassModifier systemClassModifier = methodModifiers.get(className);
if (systemClassModifier != null) {
for (String packageName : systemClassModifier.getResourceToImport()) {
cp.importPackage(packageName);
}
try {
result = methodModifiers.get(className).doTransform(className, cp, currentCtClass);
} catch (Throwable e) {
logger.error("SystemClassTransformer doTransformForDateClass error", e);
return classFileBuffer;
}
return result;
}
return classFileBuffer;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/utils/StringUtils.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/utils/StringUtils.java | package io.manbang.easybytecoder.traffichandler.utils;
/**
* @author GaoYang 2018/12/5
*/
public class StringUtils {
public static final String EMPTY = "";
public static boolean isEmpty(final CharSequence cs) {
return cs == null || cs.length() == 0;
}
public static boolean isNotEmpty(final CharSequence str) {
return !isEmpty(str);
}
public static boolean isBlank(final CharSequence cs) {
int strLen;
if (cs == null || (strLen = cs.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if (Character.isWhitespace(cs.charAt(i)) == false) {
return false;
}
}
return true;
}
public static boolean isNotBlank(final CharSequence cs) {
return !isBlank(cs);
}
public static boolean equals(String str1, String str2) {
return str1 == null ? str2 == null : str1.equals(str2);
}
public static boolean equalsIgnoreCase(String str1, String str2) {
return str1 == null ? str2 == null : str1.equalsIgnoreCase(str2);
}
public static String trim(final String str) {
return str == null ? null : str.trim();
}
public static boolean contains(String str, String searchStr) {
if (str == null || searchStr == null) {
return false;
}
return str.indexOf(searchStr) >= 0;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/SystemClassModifier.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/SystemClassModifier.java | package io.manbang.easybytecoder.traffichandler.modifier;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import java.io.IOException;
import java.util.List;
public abstract class SystemClassModifier {
public abstract String getToModifyMethodName();
public abstract List<Class<?>> getRetransformClassList();
public abstract List<String> getResourceToImport();
public byte[] doTransform(String className, ClassPool cp, CtClass ctClass) throws IOException, CannotCompileException {
return new byte[0];
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/MethodModifyCode.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/MethodModifyCode.java | package io.manbang.easybytecoder.traffichandler.modifier;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtMethod;
import java.util.List;
import java.util.Map;
public abstract class MethodModifyCode {
/**
* easyByteCoder Context处理代码段
*
* @return
*/
@Deprecated
public String handleContext() {
return "";
}
/**
* 获取需要修改的方法名MethodName
*
* @return
*/
public abstract String getToModifyMethodName();
/**
* 是否需要进行参数匹配
*
* @return
*/
public boolean ifNeedCheckParam() {
return true;
}
/**
* 该方法Modifier是否需要个性化匹配校验
*
* @return
*/
public boolean ifNeedCheckParamByOwn() {
return false;
}
/**
* 各方法Modifier个性化参数匹配校验
*
* @param argTypes
* @param classPool
* @return
*/
public boolean checkParamByOwn(CtClass[] argTypes, ClassPool classPool) {
return true;
}
/**
* 获取需要修改的方法 入参类型表
*
* @return
*/
public abstract CtClass[] getToModifyMethodParamDecl(ClassPool pool);
/**
* 在方法最前面，嵌入的代码段
*
* @return
*/
public abstract List<String> getCodeInsertBefore();
/**
* 在方法最后，嵌入的代码段
*
* @return
*/
public abstract List<String> getCodeInsertAfter();
/**
* 将方法使用tryCatch包围
* @return
*/
public CatchCode getCatchCode() {
return new CatchCode("{EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error(\"[easyByteCoder Maybe Affected]invoke method Failed!, error:\",$e); throw $e; }");
}
/**
* 在方法体替换，替换整个method body
*
* @return
*/
public String getCodeToSetBody(CtMethod method) {
return "";
}
/**
* 在方法体替换，替换整个constructor body
*
* @return
*/
public String getCodeToSetBody(CtConstructor constructor) {
return "";
}
public Map<String, CtClass> localVariables() {
return null;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/ClassModifier.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/ClassModifier.java | package io.manbang.easybytecoder.traffichandler.modifier;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtField;
import java.util.List;
public abstract class ClassModifier {
/**
* 获取要修改的类名
*
* @return
*/
public abstract String getToModifyClassName();
/**
* 获取修改该类时，需要额外引入的包名
*
* @param originLoader
* @return
*/
public abstract List<String> getResourceToImport(ClassLoader originLoader);
/**
* 获取某方法的修改实现
*
* @param methodDesc
* @return
*/
public abstract MethodModifyCode getMethodModifier(String methodDesc);
/**
* 获取修改该类时，需要加入的全局字段信息
*
* @param clazz
* @param pool
* @return
* @throws Exception
*/
public List<CtField> getFieldsToAdd(CtClass clazz, ClassPool pool) throws Exception {
return null;
}
/**
* 获取 待修改类 实现的接口类class
*
* @return
*/
public String getImplInterfaceClass() {
return "java.lang.Object";
}
// /**
// * 用于校验某个中间件代码应该拦截却没有被拦截，这里一般用能唯一识别中间件的包名
// *
// * @return
// */
// public String getPluginPackageNameForCheck(){
// return "";
// }
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/CatchCode.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/modifier/CatchCode.java | package io.manbang.easybytecoder.traffichandler.modifier;
import javassist.CtClass;
/**
* 待增加的catch代码
*
* @Author: sundaoming
* @CreateDate: 2019/5/14 11:14
*/
public class CatchCode {
String codes;
CtClass catchType;
public CatchCode(String codes) {
this.codes = codes;
}
public CatchCode(String codes, CtClass catchType) {
this.codes = codes;
this.catchType = catchType;
}
public String getCodes() {
return codes;
}
public void setCodes(String codes) {
this.codes = codes;
}
public CtClass getCatchType() {
return catchType;
}
public void setCatchType(CtClass catchType) {
this.catchType = catchType;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/serializer/EasyByteCoderGSONSerializer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/serializer/EasyByteCoderGSONSerializer.java | /**
* ymm56.com Inc.
* Copyright (c) 2013-2019 All Rights Reserved.
*/
package io.manbang.easybytecoder.traffichandler.serializer;
import com.google.gson.Gson;
import io.manbang.easybytecoder.runtimecommonapi.serialize.EasyByteCoderSerializer;
import java.util.List;
/**
*
* @author zhouhujin
* @version $Id: easyByteCoderGSONSerializer.java, v 0.1 2019-02-22 17:04 zhouhujin Exp $$
*/
public class EasyByteCoderGSONSerializer implements EasyByteCoderSerializer {
private static final Gson GSON = new Gson();
@Override
public <T> T deserialize(String json, Class<T> clazz) {
return GSON.fromJson(json, clazz);
}
@Override
public Object deserialize(String json) {
return GSON.fromJson(json, Object.class);
}
@Override
public String serialize(Object obj) {
return GSON.toJson(obj);
}
@Override
@Deprecated
public String serializeWithClassInfo(Object object) {
return GSON.toJson(object);
}
@Override
@Deprecated
public Object deserializeToArray(String json) {
return GSON.fromJson(json, Object.class);
}
@Override
@Deprecated
public <T> List<T> deserializeToArray(String json, Class<T> clazz) {
// TODO
return null;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/serializer/EasyByteCoderJSONSerializer.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/serializer/EasyByteCoderJSONSerializer.java | /**
* ymm56.com Inc.
* Copyright (c) 2013-2019 All Rights Reserved.
*/
package io.manbang.easybytecoder.traffichandler.serializer;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import io.manbang.easybytecoder.runtimecommonapi.serialize.EasyByteCoderSerializer;
import java.util.List;
/**
*
* @author zhouhujin
* @version $Id: easyByteCoderJSONSerializer.java, v 0.1 2019-02-21 14:07 zhouhujin Exp $$
*/
public class EasyByteCoderJSONSerializer implements EasyByteCoderSerializer {
@Override
public <T> T deserialize(String json, Class<T> clazz) {
return JSONObject.parseObject(json, clazz);
}
@Override
public Object deserialize(String json) {
return JSONObject.parse(json);
}
@Override
public String serialize(Object obj) {
return JSON.toJSONString(obj);
}
@Override
public String serializeWithClassInfo(Object object) {
return JSON.toJSONString(
object,
SerializerFeature.WriteMapNullValue,
SerializerFeature.QuoteFieldNames,
SerializerFeature.SkipTransientField,
SerializerFeature.WriteClassName);
}
@Override
public Object deserializeToArray(String json) {
return JSON.parseArray(json);
}
@Override
public <T> List<T> deserializeToArray(String json, Class<T> clazz) {
return JSON.parseArray(json, clazz);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/ResourceToImport.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/ResourceToImport.java | package io.manbang.easybytecoder.traffichandler.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.List;
/**
* @author xujie
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ResourceToImport {
String[] value() default "";
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/ModifyClassName.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/ModifyClassName.java | package io.manbang.easybytecoder.traffichandler.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author xujie
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ModifyClassName {
String value();
boolean SystemClass() default false;
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/ModifyMethod.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/ModifyMethod.java | package io.manbang.easybytecoder.traffichandler.annotation;
import io.manbang.easybytecoder.traffichandler.annotation.constant.CodePatternEnum;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author xujie
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ModifyMethod {
String methodName();
String[] paramDecl() default {};
CodePatternEnum pattern() default CodePatternEnum.Before;
boolean checkParam() default false;
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/process/AnnotationProcess.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/process/AnnotationProcess.java | package io.manbang.easybytecoder.traffichandler.annotation.process;
import com.google.common.collect.Lists;
import io.manbang.easybytecoder.traffichandler.AttachTrafficHandler;
import io.manbang.easybytecoder.traffichandler.BaseTransformer;
import io.manbang.easybytecoder.traffichandler.TrafficHandler;
import io.manbang.easybytecoder.traffichandler.annotation.ModifyClassName;
import io.manbang.easybytecoder.traffichandler.annotation.ModifyMethod;
import io.manbang.easybytecoder.traffichandler.annotation.ResourceToImport;
import io.manbang.easybytecoder.traffichandler.annotation.constant.CodePatternEnum;
import io.manbang.easybytecoder.traffichandler.annotation.model.ModifyMethodModel;
import io.manbang.easybytecoder.traffichandler.modifier.CatchCode;
import io.manbang.easybytecoder.traffichandler.modifier.ClassModifier;
import io.manbang.easybytecoder.traffichandler.modifier.MethodModifyCode;
import javassist.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class AnnotationProcess {
public BaseTransformer baseTransformer;
public List<String> classNameList;
public List<String> getClassNameList() {
return classNameList;
}
public BaseTransformer getBaseTransformer() {
return baseTransformer;
}
public void process(AttachTrafficHandler attachTrafficHandler, final String jarFilePath) throws InvocationTargetException, IllegalAccessException {
baseHandler(attachTrafficHandler, jarFilePath);
}
public void baseHandler(Object handler, final String jarFilePath) throws IllegalAccessException, InvocationTargetException {
ModifyClassName modifyClassNameAnnotation = handler.getClass().getAnnotation(ModifyClassName.class);
String className = null;
if (modifyClassNameAnnotation != null) {
className = modifyClassNameAnnotation.value();
}
String[] importClass = null;
ResourceToImport resourceToImportAnnotation = handler.getClass().getAnnotation(ResourceToImport.class);
if (resourceToImportAnnotation != null) {
importClass = resourceToImportAnnotation.value();
}
final String[] finalImportClass = importClass;
final String finalClassName = className;
Method[] declaredMethods = handler.getClass().getDeclaredMethods();
final HashMap<String, ModifyMethodModel> methodMap = new HashMap<>();
for (Method declaredMethod : declaredMethods) {
declaredMethod.setAccessible(true);
boolean annotationPresent = declaredMethod.isAnnotationPresent(ModifyMethod.class);
if (annotationPresent) {
ModifyMethod annotation = declaredMethod.getAnnotation(ModifyMethod.class);
modifyStrategy(handler, methodMap, declaredMethod, annotation);
}
}
HashMap<String, MethodModifyCode> methodModifiers = new HashMap<>();
for (final String methodName : methodMap.keySet()) {
MethodModifyCode methodModifier = new MethodModifyCode() {
@Override
public String getToModifyMethodName() {
return methodName;
}
@Override
public CtClass[] getToModifyMethodParamDecl(ClassPool pool) {
if (methodMap.get(methodName).getMethodParamDecl() != null && methodMap.get(methodName).getMethodParamDecl().length > 0) {
String[] paramDecl = methodMap.get(methodName).getMethodParamDecl();
int size = paramDecl.length;
CtClass[] paramList = new CtClass[size];
for (int i = 0; i < paramDecl.length; i++) {
try {
paramList[i] = pool.get(paramDecl[i]);
} catch (NotFoundException e) {
e.printStackTrace();
}
}
return paramList;
}
return new CtClass[0];
}
@Override
public List<String> getCodeInsertBefore() {
return methodMap.get(methodName).getBeforeCode();
}
@Override
public List<String> getCodeInsertAfter() {
return methodMap.get(methodName).getAfterCode();
}
@Override
public boolean ifNeedCheckParam() {
return methodMap.get(methodName).isCheckParam();
}
@Override
public CatchCode getCatchCode() {
if (methodMap.get(methodName).getCatchCode() != null) {
return methodMap.get(methodName).getCatchCode();
}
return super.getCatchCode();
}
@Override
public String getCodeToSetBody(CtMethod method) {
if (methodMap.get(methodName).getBodyCode() != null) {
return methodMap.get(methodName).getBodyCode();
}
return super.getCodeToSetBody(method);
}
@Override
public String getCodeToSetBody(CtConstructor constructor) {
return super.getCodeToSetBody(constructor);
}
@Override
public Map<String, CtClass> localVariables() {
if (methodMap.get(methodName).getLocalVariablesCode() != null) {
return methodMap.get(methodName).getLocalVariablesCode();
}
return super.localVariables();
}
};
methodModifiers.put(methodName, methodModifier);
}
final HashMap<String, MethodModifyCode> finalMethodModifiers = methodModifiers;
final ClassModifier classModifier = new ClassModifier() {
@Override
public String getToModifyClassName() {
return finalClassName;
}
@Override
public List<String> getResourceToImport(ClassLoader originLoader) {
return Lists.newArrayList(finalImportClass);
}
@Override
public MethodModifyCode getMethodModifier(String methodDesc) {
return finalMethodModifiers.get(methodDesc);
}
};
BaseTransformer baseTransformer = new BaseTransformer() {
@Override
public boolean init() {
classModifiers.put(classModifier.getToModifyClassName(), classModifier);
return true;
}
@Override
public String getRelatedJarFilePath() {
return jarFilePath;
}
@Override
public void setRelatedJarFilePath(String jarFilePath) {
}
};
baseTransformer.init();
this.classNameList = baseTransformer.getClassNameList();
this.baseTransformer = baseTransformer;
}
public void modifyStrategy(Object trafficHandler, HashMap<String, ModifyMethodModel> methodMap, Method declaredMethod, ModifyMethod annotation) throws IllegalAccessException, InvocationTargetException {
if (methodMap.get(annotation.methodName()) == null) {
ModifyMethodModel modifyMethodModel = new ModifyMethodModel();
modifyMethodModel.setCheckParam(declaredMethod.getAnnotation(ModifyMethod.class).checkParam());
String[] paramDecl = declaredMethod.getAnnotation(ModifyMethod.class).paramDecl();
if (paramDecl.length > 0) {
modifyMethodModel.setMethodParamDecl(paramDecl);
}
if (annotation.pattern() == CodePatternEnum.Before) {
String results = (String) declaredMethod.invoke(trafficHandler);
modifyMethodModel.setBeforeCode(Lists.newArrayList(results));
}
if (annotation.pattern() == CodePatternEnum.After) {
String results = (String) declaredMethod.invoke(trafficHandler);
modifyMethodModel.setAfterCode(Lists.newArrayList(results));
}
if (annotation.pattern() == CodePatternEnum.Body) {
String results = (String) declaredMethod.invoke(trafficHandler);
modifyMethodModel.setBodyCode(results);
}
if (annotation.pattern() == CodePatternEnum.Catch) {
CatchCode results = (CatchCode) declaredMethod.invoke(trafficHandler);
modifyMethodModel.setCatchCode(results);
}
if (annotation.pattern() == CodePatternEnum.LocalVariables) {
Map<String, CtClass> results = (Map<String, CtClass>) declaredMethod.invoke(trafficHandler);
modifyMethodModel.setLocalVariablesCode(results);
}
methodMap.put(annotation.methodName(), modifyMethodModel);
} else {
ModifyMethodModel modifyMethodModel = methodMap.get(annotation.methodName());
if (annotation.pattern() == CodePatternEnum.Before) {
String results = (String) declaredMethod.invoke(trafficHandler);
if(modifyMethodModel.getBeforeCode()==null){
modifyMethodModel.setBeforeCode(Lists.newArrayList(results));
}
modifyMethodModel.getBeforeCode().add(results);
}
if (annotation.pattern() == CodePatternEnum.After) {
String results = (String) declaredMethod.invoke(trafficHandler);
if(modifyMethodModel.getAfterCode()==null){
modifyMethodModel.setAfterCode(Lists.newArrayList(results));
}
modifyMethodModel.getAfterCode().add(results);
}
if (annotation.pattern() == CodePatternEnum.LocalVariables) {
Map<String, CtClass> results = (Map<String, CtClass>) declaredMethod.invoke(trafficHandler);
if(modifyMethodModel.getLocalVariablesCode()==null){
modifyMethodModel.setLocalVariablesCode(results);
}
modifyMethodModel.getLocalVariablesCode().putAll(results);
}
}
}
public void process(TrafficHandler trafficHandler, final String jarFilePath) throws InvocationTargetException, IllegalAccessException {
baseHandler(trafficHandler, jarFilePath);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/constant/CodePatternEnum.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/constant/CodePatternEnum.java | package io.manbang.easybytecoder.traffichandler.annotation.constant;
/**
* @author xujie
*/
/**
* - LocalVariables 在方法中加入局部变量
* - Before 在方法运行之前修改
* - After 在方法返回之前修改
* - Catch 自定义捕获方法异常
* - Body 替换整个方法体
*/
public enum CodePatternEnum {
LocalVariables,
Before,
After,
Catch,
Body
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/model/ModifyMethodModel.java | client/traffic-handler/src/main/java/io/manbang/easybytecoder/traffichandler/annotation/model/ModifyMethodModel.java | package io.manbang.easybytecoder.traffichandler.annotation.model;
/**
* @author xujie
*/
import io.manbang.easybytecoder.traffichandler.modifier.CatchCode;
import javassist.CtClass;
import java.util.List;
import java.util.Map;
/**
* - LocalVariables 在方法中加入局部变量
* - Before 在方法运行之前修改
* - After 在方法返回之前修改
* - Catch 自定义捕获方法异常
* - Body 替换整个方法体
*
* @author xujie
*/
public class ModifyMethodModel {
Map<String, CtClass> localVariablesCode;
List<String> beforeCode;
List<String> afterCode;
String bodyCode;
CatchCode catchCode;
boolean checkParam;
String[] MethodParamDecl;
public boolean isCheckParam() {
return checkParam;
}
public void setCheckParam(boolean checkParam) {
this.checkParam = checkParam;
}
public String[] getMethodParamDecl() {
return MethodParamDecl;
}
public void setMethodParamDecl(String[] methodParamDecl) {
MethodParamDecl = methodParamDecl;
}
public Map<String, CtClass> getLocalVariablesCode() {
return localVariablesCode;
}
public void setLocalVariablesCode(Map<String, CtClass> localVariablesCode) {
this.localVariablesCode = localVariablesCode;
}
public List<String> getBeforeCode() {
return beforeCode;
}
public void setBeforeCode(List<String> beforeCode) {
this.beforeCode = beforeCode;
}
public List<String> getAfterCode() {
return afterCode;
}
public void setAfterCode(List<String> afterCode) {
this.afterCode = afterCode;
}
public String getBodyCode() {
return bodyCode;
}
public void setBodyCode(String bodyCode) {
this.bodyCode = bodyCode;
}
public CatchCode getCatchCode() {
return catchCode;
}
public void setCatchCode(CatchCode catchCode) {
this.catchCode = catchCode;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/serialize/EasyByteCoderSerializer.java | client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/serialize/EasyByteCoderSerializer.java | /**
* ymm56.com Inc.
* Copyright (c) 2013-2019 All Rights Reserved.
*/
package io.manbang.easybytecoder.runtimecommonapi.serialize;
import java.util.List;
/**
*
* @author zhouhujin
* @version $Id: DoomSerializer.java, v 0.1 2019-02-21 14:05 zhouhujin Exp $$
*/
public interface EasyByteCoderSerializer {
<T> T deserialize(String json, Class<T> clazz);
Object deserialize(String json);
String serialize(Object obj);
String serializeWithClassInfo(Object object);
Object deserializeToArray(String json);
<T> List<T> deserializeToArray(String json, Class<T> clazz);
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/constant/EasyByteCoderConstants.java | client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/constant/EasyByteCoderConstants.java | package io.manbang.easybytecoder.runtimecommonapi.constant;
import java.util.Arrays;
import java.util.List;
/**
* @author xujie
*/
public class EasyByteCoderConstants {
public static final List<String> YMM_ACCEPT = Arrays.asList("com.ymm.", "com.ymm56.", "com.zf.", "com.mb.");
/**
* easyByteCoder 日志类，将easyByteCoder内的日志与应用日志隔离
*/
public static final String EasyByteCoder_LOGGER_CLASS = "io.manbang.easybytecoder.traffichandler.logger.EasyByteCoderClientLogger";
/**
* easyByteCoder 中携带的fastjson类，版本较高，不依赖所注入应用是否引用fastjson，以及应用中使用的fastjosn版本
*/
public static final String EasyByteCoder_SERIALIZER_JSON_CLASS = "io.manbang.easybytecoder.traffichandler.serializer.EasyByteCoderJSONSerializer";
public static final String EasyByteCoder_SERIALIZER_GSON_CLASS = "io.manbang.easybytecoder.traffichandler.serializer.EasyByteCoderGSONSerializer";
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/utils/EasyByteCoderResourceObjectPool.java | client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/utils/EasyByteCoderResourceObjectPool.java | package io.manbang.easybytecoder.runtimecommonapi.utils;
import io.manbang.easybytecoder.runtimecommonapi.constant.EasyByteCoderConstants;
import io.manbang.easybytecoder.runtimecommonapi.log.EasyByteCoderLogger;
import io.manbang.easybytecoder.runtimecommonapi.serialize.EasyByteCoderSerializer;
import java.lang.reflect.Method;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Map;
/**
* @author GaoYang 2018/12/23
*/
public class EasyByteCoderResourceObjectPool {
private static Map<String, Object> objectCache = new HashMap<>();
private static Map<String, Method> methodCache = new HashMap<>();
private static volatile URLClassLoader bootClassLoader;
public static void init(URLClassLoader classLoader) {
EasyByteCoderResourceObjectPool.bootClassLoader = classLoader;
getFromCache(EasyByteCoderConstants.EasyByteCoder_LOGGER_CLASS);
getFromCache(EasyByteCoderConstants.EasyByteCoder_SERIALIZER_JSON_CLASS);
}
public static EasyByteCoderLogger getEasyByteCoderLogger() {
return (EasyByteCoderLogger) getFromCache(EasyByteCoderConstants.EasyByteCoder_LOGGER_CLASS);
}
public static EasyByteCoderSerializer getJsonSerializer() {
return (EasyByteCoderSerializer) getFromCache(EasyByteCoderConstants.EasyByteCoder_SERIALIZER_JSON_CLASS);
}
public static EasyByteCoderSerializer getGsonSerializer() {
return (EasyByteCoderSerializer) getFromCache(EasyByteCoderConstants.EasyByteCoder_SERIALIZER_GSON_CLASS);
}
/**
* 获取easyByteCoder空间加载的类
*
* @param classname 需要的easyByteCoder空间内的类名
* @return easyByteCoder空间内的类
*/
public static Class getEasyByteCoderClass(String classname) {
try {
return bootClassLoader.loadClass(classname);
} catch (Exception e) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger()
.error("ERROR loadClass is null:getEasyByteCoderClass:" + classname, e);
return null;
}
}
/**
* 获取“应用空间”运行时加载的类
*
* @param classname 需要的 “应用空间”内的类名
* @return 应用空间内的类
*/
public static Class getRuntimeClass(String classname) {
try {
return Thread.currentThread().getContextClassLoader().loadClass(classname);
} catch (Exception e) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger()
.error("ERROR loadClass is null:getRuntimeClass:" + classname, e);
return null;
}
}
/**
* 获取runtime中运行的类方法，并缓存起来
*/
public static Method getNotOverloadRuntimeMethodFromCache(
String className, String methodName, Class<?>... parameterTypes) {
Method method = methodCache.get(className + ":" + methodName);
try {
if (method == null) {
Class baseTransformClass = getRuntimeClass(className);
method = baseTransformClass.getMethod(methodName, parameterTypes);
methodCache.put(className + ":" + methodName, method);
}
} catch (Exception e) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("getNotOverloadRuntimeMethodFromCache error:", e);
}
return method;
}
/**
* 获取easyByteCoder中的类，并缓存起来
*/
public static Object getFromCache(String packageClassName) {
Object obj = objectCache.get(packageClassName);
if (obj != null) {
return obj;
}
try {
if (EasyByteCoderResourceObjectPool.bootClassLoader == null) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("ERROR is null:Agent.bootstrapObj");
return null;
}
Class logFactoryClass = bootClassLoader.loadClass(packageClassName);
if (logFactoryClass == null) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("logFactoryClass is null");
} else {
Object objNew = logFactoryClass.newInstance();
if (objNew == null) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("logFactoryClass is null");
} else {
objectCache.put(packageClassName, objNew);
}
}
} catch (Exception e) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("getFromCache error:", e);
}
return objectCache.get(packageClassName);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/utils/SystemModifierUtil.java | client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/utils/SystemModifierUtil.java | package io.manbang.easybytecoder.runtimecommonapi.utils;
/**
* 系统函数修改后的实现
*
* @Author: sundaoming
* @CreateDate: 2019/4/22 15:31
*/
public class SystemModifierUtil {
private static long now = System.currentTimeMillis();
private static long nowNano = System.nanoTime();
public static long currentTimeMillis(){
long freezeTime = now;
if ( freezeTime > 0) {
return freezeTime;
}else{
long realTime = now + (System.nanoTime() - nowNano)/1000000L;
//System.out.println("WARNING! SystemModifierUtil:currentTimeMillis>> useing real currentTime : " + realTime);
return realTime;
}
}
public static long getRealCurrenttime() {
return now + (System.nanoTime() -nowNano)/1000000L;
}
@Deprecated
public static long syncToFreezeTime(long timeStamp){
if (now > 0) {
long userDefinedDiffTime = timeStamp - now;
if (userDefinedDiffTime >= 0) {
userDefinedDiffTime = (userDefinedDiffTime/1000) *1000;
} else {
userDefinedDiffTime = (userDefinedDiffTime/1000) *1000 -1000L;
}
long newTimeStamp = userDefinedDiffTime + now;
if (timeStamp != newTimeStamp) {
System.out.println("xxxxxxxxxxxx originTimeStamp: " + timeStamp + " newTimeStamp: "
+ newTimeStamp);
}
return newTimeStamp;
}else{
return timeStamp;
}
}
@Deprecated
public static long syncToFreezeTimeForMockMode(long timeStamp){
long timeCoodinate = now;
if (timeCoodinate > 0) {
if (Math.abs(timeStamp-timeCoodinate) > 1000) {
}
long userDefinedDiffTime = timeStamp - now;
if (userDefinedDiffTime >= 0) {
userDefinedDiffTime = (userDefinedDiffTime/1000) *1000;
} else {
userDefinedDiffTime = (userDefinedDiffTime/1000) *1000 -1000L;
}
long newTimeStamp = userDefinedDiffTime + now;
if (timeStamp != newTimeStamp) {
System.out.println("xxxxxxxxxxxx originTimeStamp: " + timeStamp + " newTimeStamp: "
+ newTimeStamp);
}
return newTimeStamp;
}else{
return timeStamp;
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/utils/StringUtils.java | client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/utils/StringUtils.java | package io.manbang.easybytecoder.runtimecommonapi.utils;
/**
* @author GaoYang
* 2018/12/23
*/
public class StringUtils {
public static final String EMPTY = "";
public static boolean isEmpty(final CharSequence cs) {
return cs == null || cs.length() == 0;
}
public static boolean isNotEmpty(final CharSequence str) {
return !isEmpty(str);
}
public static boolean isBlank(final CharSequence cs) {
int strLen;
if (cs == null || (strLen = cs.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if (Character.isWhitespace(cs.charAt(i)) == false) {
return false;
}
}
return true;
}
public static boolean isNotBlank(final CharSequence cs) {
return !isBlank(cs);
}
public static boolean equals(String str1, String str2) {
return str1 == null ? str2 == null : str1.equals(str2);
}
public static boolean equalsIgnoreCase(String str1, String str2) {
return str1 == null ? str2 == null : str1.equalsIgnoreCase(str2);
}
public static String trim(final String str) {
return str == null ? null : str.trim();
}
public static boolean contains(String str, String searchStr) {
if (str == null || searchStr == null) {
return false;
}
return str.indexOf(searchStr) >= 0;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/log/EasyByteCoderLogger.java | client/runtime-common-api/src/main/java/io/manbang/easybytecoder/runtimecommonapi/log/EasyByteCoderLogger.java | package io.manbang.easybytecoder.runtimecommonapi.log;
/**
* @author GaoYang
* 2018/12/23
*/
public interface EasyByteCoderLogger {
void debug(String var1);
void debug(String format, Object arg);
void debug(String format, Object arg1, Object arg2);
void debug(String format, Object... arguments);
void info(String var1);
void warn(String var1);
void error(String var1);
void error(String var1, Throwable e);
void error(String format, Object... arguments);
void trace(String var1);
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/plugins/spring-plugin/src/main/java/io/manbang/easybytecoder/plugin/springplugin/SpringPlugin.java | client/plugins/spring-plugin/src/main/java/io/manbang/easybytecoder/plugin/springplugin/SpringPlugin.java | package io.manbang.easybytecoder.plugin.springplugin;
import com.google.auto.service.AutoService;
import io.manbang.easybytecoder.traffichandler.TrafficHandler;
import io.manbang.easybytecoder.traffichandler.annotation.ModifyClassName;
import io.manbang.easybytecoder.traffichandler.annotation.ModifyMethod;
import io.manbang.easybytecoder.traffichandler.annotation.ResourceToImport;
/**
* @author xujie
*/
@AutoService(TrafficHandler.class)
@ModifyClassName("org/springframework/context/support/AbstractApplicationContext")
@ResourceToImport({"io.manbang.easybytecoder.runtimecommonapi.utils.EasyByteCoderResourceObjectPool",
"io.manbang.easybytecoder.plugin.springplugin.modify.runtime.RegisterAspectAdvice"})
public class SpringPlugin implements TrafficHandler {
@ModifyMethod(methodName = "invokeBeanFactoryPostProcessors")
public String modify() {
return "RegisterAspectAdvice.registerAspect($1);";
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/plugins/spring-plugin/src/main/java/io/manbang/easybytecoder/plugin/springplugin/modify/runtime/ArgumentPrintAspect.java | client/plugins/spring-plugin/src/main/java/io/manbang/easybytecoder/plugin/springplugin/modify/runtime/ArgumentPrintAspect.java | package io.manbang.easybytecoder.plugin.springplugin.modify.runtime;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
/**
* @author xujie
*/
@Slf4j
@Aspect
@Component
public class ArgumentPrintAspect {
@Around("(@within(org.springframework.stereotype.Service) || @within(org.springframework.stereotype.Repository) || @within(org.springframework.stereotype.Controller))) " +
"&& execution(public * *(..))")
public Object printIoArgument(ProceedingJoinPoint point) throws Throwable {
log.info("【入参】 {}", point.getArgs());
Object result = point.proceed();
log.info("【出参】 {}", result);
return result;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/plugins/spring-plugin/src/main/java/io/manbang/easybytecoder/plugin/springplugin/modify/runtime/RegisterAspectAdvice.java | client/plugins/spring-plugin/src/main/java/io/manbang/easybytecoder/plugin/springplugin/modify/runtime/RegisterAspectAdvice.java | package io.manbang.easybytecoder.plugin.springplugin.modify.runtime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
/**
* @author xujie
*/
public class RegisterAspectAdvice {
public static void registerAspect( ConfigurableListableBeanFactory beanFactory) {
Logger log = LoggerFactory.getLogger("RegisterAspectAdvice");
log.info("注册参数切面");
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
BeanDefinition definition = BeanDefinitionBuilder.genericBeanDefinition("io.manbang.easybytecoder.plugin.springplugin.modify.runtime.ArgumentPrintAspect").getBeanDefinition();
registry.registerBeanDefinition("argumentPrintAspect", definition);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/plugins/simple-hotfix/src/main/java/io/manbang/easybytecoder/plugin/simplehotfix/SimplePlugin.java | client/plugins/simple-hotfix/src/main/java/io/manbang/easybytecoder/plugin/simplehotfix/SimplePlugin.java | package io.manbang.easybytecoder.plugin.simplehotfix;
import com.google.auto.service.AutoService;
import io.manbang.easybytecoder.traffichandler.AttachTrafficHandler;
import io.manbang.easybytecoder.traffichandler.annotation.ModifyClassName;
import io.manbang.easybytecoder.traffichandler.annotation.ModifyMethod;
import io.manbang.easybytecoder.traffichandler.annotation.ResourceToImport;
import io.manbang.easybytecoder.traffichandler.annotation.constant.CodePatternEnum;
/**
* @author xujie
*/
@AutoService(AttachTrafficHandler.class)
@ResourceToImport({
"io.manbang.easybytecoder.runtimecommonapi.utils.EasyByteCoderResourceObjectPool",
"io.manbang.easybytecoder.plugin.simplehotfix.mock.runtime.FixHandle"
})
@ModifyClassName("io/manbang/helloworld/HelloWorld")
public class SimplePlugin implements AttachTrafficHandler {
@ModifyMethod(methodName = "runPrint", pattern = CodePatternEnum.Before)
public String modifyBefore() {
return "$1=FixHandle.fixModel($1);";
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/plugins/simple-hotfix/src/main/java/io/manbang/easybytecoder/plugin/simplehotfix/mock/runtime/FixHandle.java | client/plugins/simple-hotfix/src/main/java/io/manbang/easybytecoder/plugin/simplehotfix/mock/runtime/FixHandle.java | package io.manbang.easybytecoder.plugin.simplehotfix.mock.runtime;
import io.manbang.helloworld.HelloWorld.UserModel;
/**
* @author xujie
*/
public class FixHandle {
public static UserModel fixModel(UserModel userModel) {
if (userModel == null) {
UserModel newUserModel = new UserModel();
newUserModel.setName("zhangsan");
newUserModel.setAge(18);
return newUserModel;
}
return userModel;
}
public static void test() {
System.out.println("111");
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/EasyByteCoderClientBootStrap.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/EasyByteCoderClientBootStrap.java | package io.manbang.easybytecoder.clientbootstrap;
import com.sun.net.httpserver.HttpServer;
import io.manbang.easybytecoder.clientbootstrap.server.HttpHandlerTools;
import io.manbang.easybytecoder.clientbootstrap.server.model.AgentInfo;
import io.manbang.easybytecoder.clientbootstrap.util.SystemClassTransformerProxy;
import io.manbang.easybytecoder.clientbootstrap.util.SystemHandler;
import io.manbang.easybytecoder.traffichandler.AttachTrafficHandler;
import io.manbang.easybytecoder.traffichandler.BaseTransformer;
import io.manbang.easybytecoder.traffichandler.TrafficHandler;
import io.manbang.easybytecoder.traffichandler.annotation.process.AnnotationProcess;
import io.manbang.easybytecoder.traffichandler.systemhandler.SystemClassTransformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.util.*;
import static io.manbang.easybytecoder.clientbootstrap.server.HttpThreadPool.httpServerPool;
/**
* @author GaoYang 2018/12/23
*/
public class EasyByteCoderClientBootStrap {
private static Logger logger = LoggerFactory.getLogger(EasyByteCoderClientBootStrap.class);
public static final String ARGS_PLUGINS = "plugins";
public void init(Instrumentation instrumentation, String pluginBasePath, Map<String, String> agentArgs) {
// 1. 获取生效plugin名称 与 运行参数
List<String> pluginJarFiles = getPluginJarName(agentArgs);
// 2. 加载相关pluging Jar文件
ClassLoader pluginClassLoader = PluginClassLoaderFactory.createPluginClassLoader(EasyByteCoderClientBootStrap.class.getClassLoader(), new File(pluginBasePath), pluginJarFiles);
if (pluginClassLoader == null) {
logger.error("no easyByteCoder plugin available, please check");
throw new IllegalStateException("no easyByteCoder plugin available, please check");
}
// 加载插件
loadAndInitPlugins(instrumentation, pluginClassLoader, agentArgs);
}
private static List<String> getPluginJarName(Map<String, String> agentArgsMap) {
String pluginJarsString = agentArgsMap.get(ARGS_PLUGINS.toLowerCase());
String[] pluginNames = pluginJarsString.split(",");
return Arrays.asList(pluginNames);
}
private void loadAndInitPlugins(Instrumentation instrumentation, ClassLoader pluginClassLoader, Map<String, String> agentArgsMap) {
// 3. 获取SPI 实现类
ServiceLoader<TrafficHandler> serviceLoader = ServiceLoader.load(TrafficHandler.class, pluginClassLoader);
// 4. 初始化TrafficHandler.class 相关plugin的实现类， 并添加到instrument的Transformer中
for (TrafficHandler trafficHandler : serviceLoader) {
try {
initPlugin(instrumentation, trafficHandler, agentArgsMap);
} catch (Throwable throwable) {
logger.error("init trafficHandler error, className: " + trafficHandler.getClass().getName(), throwable);
}
}
}
/**
* 初始化插件
*
* @param instrumentation
* @param agentArgsMap
* @param trafficHandler
*/
private void initPlugin(Instrumentation instrumentation, TrafficHandler trafficHandler, Map<String, String> agentArgsMap) {
String jarFilePath = trafficHandler.getClass().getProtectionDomain().getCodeSource().getLocation().getFile();
logger.info("initing plugin, name: {}, jar path: {}", trafficHandler.getClass().getName(), jarFilePath);
//trafficHandler.init(jarFilePath, agentArgsMap);
AnnotationProcess annotationProcess = new AnnotationProcess();
try {
annotationProcess.process(trafficHandler, jarFilePath);
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//普通类的修改
if (annotationProcess.getBaseTransformer() instanceof BaseTransformer) {
ClassFileTransformer transformer = annotationProcess.getBaseTransformer();
if (transformer != null) {
logger.info("adding transformer {}", transformer.getClass().getName());
instrumentation.addTransformer(transformer, true);
}
}
//系统类的修改
// if (trafficHandler.getTransformer() instanceof SystemClassTransformer) {
// addSystemTransformer(instrumentation, trafficHandler, agentArgsMap);
// }
}
/**
* attach 核心方法
*
* @param agentArgs
* @param inst
*/
public static void agentmain(String agentArgs, Instrumentation inst) {
String pathName = agentArgs.replace("bootstrap.jar", "");
List<String> pluginJarFiles = getAttachFileList(pathName);
logger.info("agent attach start");
ClassLoader pluginClassLoader = PluginClassLoaderFactory.createPluginClassLoader(EasyByteCoderClientBootStrap.class.getClassLoader(), new File(pathName), pluginJarFiles);
ServiceLoader<AttachTrafficHandler> serviceLoader = ServiceLoader.load(AttachTrafficHandler.class, pluginClassLoader);
List<AgentInfo> agentInfoList = new ArrayList<>();
AnnotationProcess annotationProcess = new AnnotationProcess();
for (AttachTrafficHandler trafficHandler : serviceLoader) {
try {
String jarFilePath = trafficHandler.getClass().getProtectionDomain().getCodeSource().getLocation().getFile();
logger.info("initing plugin, name: {}, jar path: {}", trafficHandler.getClass().getName(), jarFilePath);
annotationProcess.process(trafficHandler, jarFilePath);
if (annotationProcess.getBaseTransformer() instanceof BaseTransformer) {
ClassFileTransformer transformer = annotationProcess.getBaseTransformer();
AgentInfo agentInfo = new AgentInfo();
agentInfo.setClassFileTransformer(transformer);
if (transformer != null) {
logger.info("adding transformer {}", transformer.getClass().getName());
inst.addTransformer(transformer, true);
for (Class<?> clazz : inst.getAllLoadedClasses()) {
if (annotationProcess.getClassNameList().contains(clazz.getName())) {
inst.retransformClasses(clazz);
agentInfo.getClazzs().add(clazz);
}
}
}
agentInfoList.add(agentInfo);
}
} catch (Throwable throwable) {
logger.error("init trafficHandler error, className: " + trafficHandler.getClass().getName(), throwable);
}
}
httpServer(inst, agentInfoList);
}
/**
* 本地http服务
*/
public static void httpServer(Instrumentation inst, List<AgentInfo> agentInfos) {
HttpServer httpServer = null;
try {
logger.info("enablement doomHttpServer!!!! port:8089");
httpServer = HttpServer.create(new InetSocketAddress(8089), 0);
//创建一个HttpContext，将路径为/myserver请求映射到MyHttpHandler处理器
httpServer.createContext("/server", new HttpHandlerTools(inst, agentInfos) {});
//设置服务器的线程池对象
httpServer.setExecutor(httpServerPool);
//启动服务器
httpServer.start();
} catch (IOException e) {
logger.error("httpServer start error:", e);
if (httpServer == null) {
return;
}
httpServerPool.shutdown();
httpServer.stop(1);
}
}
private static List<String> getAttachFileList(String jarPath) {
List<String> attachJarNames = new ArrayList<>();
File file = new File(jarPath);
File[] fileList = file.listFiles();
for (int i = 0; i < fileList.length; i++) {
if (fileList[i].isFile()) {
String fileName = fileList[i].getName();
attachJarNames.add(fileName);
}
}
return attachJarNames;
}
private static void addSystemTransformer(Instrumentation instrumentation, ClassFileTransformer classFileTransformer, Map<String, String> agentArgsMap) {
try {
SystemHandler systemHandler = new SystemHandler((SystemClassTransformer) classFileTransformer, instrumentation);
SystemClassTransformerProxy systemClassTransformerProxy = new SystemClassTransformerProxy(systemHandler);
systemClassTransformerProxy.addSystemTransformer();
} catch (Throwable e) {
logger.error("ERROR: addSystemTransformer error!", e);
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/PluginClassLoaderFactory.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/PluginClassLoaderFactory.java | package io.manbang.easybytecoder.clientbootstrap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.Closeable;
import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Collection;
import java.util.List;
import java.util.jar.JarFile;
/**
* @author GaoYang 2018/12/10
*/
public class PluginClassLoaderFactory {
private static final Logger logger = LoggerFactory.getLogger(PluginClassLoaderFactory.class);
public static URLClassLoader createPluginClassLoader(final ClassLoader parentClassLoader, final File base, List<String> pluginJarNames) {
logger.info("plugins to be loaded: {}", pluginJarNames);
if (base == null || !base.canRead() || !base.isDirectory()) {
return null;
}
File[] files = base.listFiles(new PluginJarFileFilter(pluginJarNames));
if (null == files || 0 == files.length) {
logger.error("not find any plugin jars in the directory:{}", base.getAbsolutePath());
return null;
}
logger.info("find plugin jars in the directory: {} ,plugin count: {}", base.getAbsolutePath(), files.length);
URL[] elements = new URL[files.length];
for (int j = 0; j < files.length; j++) {
try {
URL element = files[j].toURI().normalize().toURL();
elements[j] = element;
logger.info("Adding '{}' to classloader", element.toString());
} catch (MalformedURLException e) {
logger.error("load jar file error", e);
}
}
return URLClassLoader.newInstance(elements, parentClassLoader);
}
public static void closeIfPossible(URLClassLoader urlClassLoader) {
// 如果是JDK7+的版本, URLClassLoader实现了Closeable接口，直接调用即可
if (urlClassLoader instanceof Closeable) {
try {
((Closeable) urlClassLoader).close();
} catch (Throwable cause) {
// ignore...
}
return;
}
// 对于JDK6的版本，URLClassLoader要关闭起来就显得有点麻烦，这里弄了一大段代码来稍微处理下
// 而且还不能保证一定释放干净了，至少释放JAR文件句柄是没有什么问题了
try {
final Object sun_misc_URLClassPath = forceGetDeclaredFieldValue(URLClassLoader.class, "ucp", urlClassLoader);
final Object java_util_Collection = forceGetDeclaredFieldValue(sun_misc_URLClassPath.getClass(), "loaders", sun_misc_URLClassPath);
for (final Object sun_misc_URLClassPath_JarLoader :
((Collection) java_util_Collection).toArray()) {
try {
final JarFile java_util_jar_JarFile = forceGetDeclaredFieldValue(sun_misc_URLClassPath_JarLoader.getClass(), "jar", sun_misc_URLClassPath_JarLoader);
java_util_jar_JarFile.close();
} catch (Throwable t) {
// if we got this far, this is probably not a JAR loader so skip it
}
}
} catch (Throwable cause) {
// ignore...
}
}
private static <T> T forceGetDeclaredFieldValue(Class<?> clazz, String name, Object target) throws NoSuchFieldException, IllegalAccessException {
final Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
return (T) field.get(target);
}
private static class PluginJarFileFilter implements FileFilter {
private List<String> jarFileNames;
public PluginJarFileFilter(List<String> jarFileNames) {
this.jarFileNames = jarFileNames;
}
@Override
public boolean accept(File f) {
if (jarFileNames.contains(f.getName())) {
return true;
}
return false;
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/SystemHandler.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/SystemHandler.java | package io.manbang.easybytecoder.clientbootstrap.util;
import io.manbang.easybytecoder.traffichandler.systemhandler.SystemClassTransformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.instrument.Instrumentation;
/**
* @author xujie
*/
public class SystemHandler implements ISystemClassTransformer {
private SystemClassTransformer systemClassTransformer;
private Instrumentation instrumentation;
private static Logger logger = LoggerFactory.getLogger(SystemHandler.class);
public SystemHandler(SystemClassTransformer systemClassTransformer, Instrumentation instrumentation) {
this.systemClassTransformer = systemClassTransformer;
this.instrumentation = instrumentation;
}
@Override
public void addSystemTransformer() {
if (systemClassTransformer == null) {
return;
}
try {
for (Class<?> listClass : systemClassTransformer.getListClass()) {
instrumentation.retransformClasses(listClass);
instrumentation.addTransformer(systemClassTransformer, true);
}
} catch (Exception e) {
logger.error("SystemHandler addSystemTransformer err:", e);
}
}
@Override
public String getSystemClassName() {
return systemClassTransformer.getClass().getSimpleName();
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/ISystemClassTransformer.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/ISystemClassTransformer.java | package io.manbang.easybytecoder.clientbootstrap.util;
/**
* @author xujie
*/
public interface ISystemClassTransformer {
void addSystemTransformer();
String getSystemClassName();
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/SystemClassTransformerProxy.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/SystemClassTransformerProxy.java | package io.manbang.easybytecoder.clientbootstrap.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author xujie
*/
public class SystemClassTransformerProxy {
private ISystemClassTransformer systemClassTransformer;
private static Logger logger = LoggerFactory.getLogger(SystemClassTransformerProxy.class);
public SystemClassTransformerProxy(ISystemClassTransformer systemClassTransformer) {
this.systemClassTransformer = systemClassTransformer;
}
public void addSystemTransformer() {
logger.warn("className： "+systemClassTransformer.getSystemClassName()+" Modifying the system method");
systemClassTransformer.addSystemTransformer();
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/BannerHelper.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/util/BannerHelper.java | package io.manbang.easybytecoder.clientbootstrap.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class BannerHelper {
public static void banner(String path) {
BufferedReader in = null;
try {
in = new BufferedReader(new FileReader(new File(path)));
String str = "";
while ((str = in.readLine()) != null) {
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/server/HttpThreadPool.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/server/HttpThreadPool.java | package io.manbang.easybytecoder.clientbootstrap.server;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class HttpThreadPool {
public static ExecutorService httpServerPool = new ThreadPoolExecutor(5, 5,
0L, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<Runnable>(20), new ThreadPoolExecutor.AbortPolicy());
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/server/HttpHandlerTools.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/server/HttpHandlerTools.java | package io.manbang.easybytecoder.clientbootstrap.server;
import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import io.manbang.easybytecoder.clientbootstrap.server.model.AgentInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.util.List;
import java.util.Map;
/**
* @author xujie
*/
public class HttpHandlerTools implements com.sun.net.httpserver.HttpHandler {
private static Logger logger = LoggerFactory.getLogger(HttpHandlerTools.class);
private List<AgentInfo> agentInfos;
private Instrumentation inst;
private String commandUninstall = "uninstall";
public HttpHandlerTools(Instrumentation inst, List<AgentInfo> agentInfos) {
this.agentInfos = agentInfos;
this.inst = inst;
}
@Override
public void handle(HttpExchange httpExchange) {
try {
StringBuilder responseText = new StringBuilder();
String param = getRequestParam(httpExchange);
if (commandUninstall.equals(param)) {
uninstallTransformer();
}
handleResponse(httpExchange, responseText.toString());
} catch (Exception ex) {
logger.error("headler fail error", ex);
}
}
private void uninstallTransformer() {
for (AgentInfo agentInfo : agentInfos) {
inst.removeTransformer(agentInfo.getClassFileTransformer());
for (Class<?> clazz : agentInfo.getClazzs()) {
try {
inst.retransformClasses(clazz);
} catch (UnmodifiableClassException e) {
logger.error("uninstall Transformer faill error ", e);
}
logger.info("Remove Instrumentation className:{}", clazz.getSimpleName());
}
}
}
/**
* 获取请求头
*
* @param httpExchange
* @return
*/
private String getRequestHeader(HttpExchange httpExchange) {
Headers headers = httpExchange.getRequestHeaders();
StringBuilder builder = new StringBuilder();
for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
builder.append(entry.getKey());
builder.append(":");
builder.append(entry.getValue().toString());
builder.append("<br/>");
}
//java8
// return headers.entrySet().stream().map((Map.Entry<String, List<String>> entry) -> entry.getKey() + ":" + entry.getValue().toString()).collect(Collectors.joining("<br/>"));
return builder.toString();
}
/**
* 获取请求参数
*
* @param httpExchange
* @return
* @throws Exception
*/
private String getRequestParam(HttpExchange httpExchange) throws Exception {
String paramStr = "";
if (httpExchange.getRequestMethod().equals("GET")) {
//GET请求读queryString
paramStr = httpExchange.getRequestURI().getQuery();
} else {
//非GET请求读请求体
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(httpExchange.getRequestBody(), "utf-8"));
StringBuilder requestBodyContent = new StringBuilder();
String line = null;
while ((line = bufferedReader.readLine()) != null) {
requestBodyContent.append(line);
}
paramStr = requestBodyContent.toString();
}
return paramStr;
}
/**
* 处理响应
*
* @param httpExchange
* @param responsetext
* @throws Exception
*/
private void handleResponse(HttpExchange httpExchange, String responsetext) throws Exception {
//生成html
StringBuilder responseContent = new StringBuilder();
responseContent.append("<html>")
.append("<body>")
.append(responsetext)
.append("</body>")
.append("</html>");
String responseContentStr = responseContent.toString();
byte[] responseContentByte = responseContentStr.getBytes("utf-8");
//设置响应头，必须在sendResponseHeaders方法之前设置！
httpExchange.getResponseHeaders().add("Content-Type:", "text/html;charset=utf-8");
//设置响应码和响应体长度，必须在getResponseBody方法之前调用！
httpExchange.sendResponseHeaders(200, responseContentByte.length);
OutputStream out = httpExchange.getResponseBody();
out.write(responseContentByte);
out.flush();
out.close();
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/server/model/AgentInfo.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/server/model/AgentInfo.java | package io.manbang.easybytecoder.clientbootstrap.server.model;
import java.lang.instrument.ClassFileTransformer;
import java.util.ArrayList;
import java.util.List;
/**
* @author xujie
*/
public class AgentInfo {
ClassFileTransformer classFileTransformer;
List<Class<?>> clazzs;
public AgentInfo() {
this.clazzs = new ArrayList<>();
}
public ClassFileTransformer getClassFileTransformer() {
return classFileTransformer;
}
public void setClassFileTransformer(ClassFileTransformer classFileTransformer) {
this.classFileTransformer = classFileTransformer;
}
public List<Class<?>> getClazzs() {
return clazzs;
}
public void setClazzs(List<Class<?>> clazzs) {
this.clazzs = clazzs;
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/LoaderMenu.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/LoaderMenu.java | package io.manbang.easybytecoder.clientbootstrap.Loder;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import io.manbang.easybytecoder.clientbootstrap.Loder.gui.ViewMenu;
import java.io.IOException;
import java.util.HashMap;
import java.util.Scanner;
/**
* @author xujie
*/
public class LoaderMenu {
public void displayMenu() {
printSpacing(2);
printSelectPid();
}
private void printSpacing(int line) {
for (int i = 0; i < line; i++) {
System.out.println("\n");
}
}
private void printSelectPid() {
HashMap<String, String> processNameAndPid = getProcessNameAndPid();
HashMap<String, String> newProcessNameAndPid = new HashMap<>(10);
for (String processName : processNameAndPid.keySet()) {
String[] name = processName.split(" ");
newProcessNameAndPid.put(name[0], processNameAndPid.get(processName));
}
try {
new ViewMenu().SelectPid(newProcessNameAndPid);
} catch (IOException e) {
e.printStackTrace();
}
}
private HashMap<String, String> getProcessNameAndPid() {
HashMap<String, String> ProcessNamePidMapping = new HashMap<>(10);
for (VirtualMachineDescriptor jvm : VirtualMachine.list()) {
ProcessNamePidMapping.put(jvm.displayName(), jvm.id());
}
return ProcessNamePidMapping;
}
private void ScannerKeyboard() {
Scanner sc = new Scanner(System.in);
System.out.println("ScannerTest, Please Enter Name:");
String name = sc.nextLine(); //读取字符串型输入
System.out.println("ScannerTest, Please Enter Age:");
int age = sc.nextInt(); //读取整型输入
System.out.println("ScannerTest, Please Enter Salary:");
float salary = sc.nextFloat(); //读取float型输入
System.out.println("Your Information is as below:");
System.out.println("Name:" + name + "\n" + "Age:" + age + "\n" + "Salary:" + salary);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/AgentLoader.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/AgentLoader.java | package io.manbang.easybytecoder.clientbootstrap.Loder;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import java.io.File;
/**
* @author xujie
*/
public class AgentLoader {
public static void run(String bootstrapJarPath) {
new LoaderMenu().displayMenu();
}
public static void start(String pid){
if (VirtualMachine.list() == null) {
System.out.println("err VirtualMachine list==null");
return;
}
VirtualMachineDescriptor virtualMachineDescriptor = null;
for (VirtualMachineDescriptor jvm : VirtualMachine.list()) {
if (jvm.id().equals(pid)) {
virtualMachineDescriptor = jvm;
break;
}
}
if (virtualMachineDescriptor == null) {
System.out.println("Target Application not found");
return;
}
String path=System.getProperty("user.dir");
String jarName=System.getProperty("java.class.path");
String bootPath=path+"/"+jarName;
File agentFile = new File(bootPath);
try {
System.out.println("Attaching to target JVM with PID: " +pid);
VirtualMachine jvm = VirtualMachine.attach(pid);
jvm.loadAgent(agentFile.getAbsolutePath(), bootPath);
jvm.detach();
System.out.println("Attached to target JVM and loaded Java agent successfully");
} catch (Exception e) {
e.printStackTrace();
}
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/Launcher.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/Launcher.java | package io.manbang.easybytecoder.clientbootstrap.Loder;
public class Launcher {
public static void main(String[] args) {
String bootstrapJarPath = "";
AgentLoader.run(bootstrapJarPath);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/gui/ViewMenu.java | client/client-bootstrap/src/main/java/io/manbang/easybytecoder/clientbootstrap/Loder/gui/ViewMenu.java | package io.manbang.easybytecoder.clientbootstrap.Loder.gui;
import com.googlecode.lanterna.TextColor;
import com.googlecode.lanterna.gui2.*;
import com.googlecode.lanterna.gui2.dialogs.MessageDialog;
import com.googlecode.lanterna.gui2.dialogs.MessageDialogBuilder;
import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton;
import com.googlecode.lanterna.gui2.table.Table;
import com.googlecode.lanterna.screen.Screen;
import com.googlecode.lanterna.screen.TerminalScreen;
import com.googlecode.lanterna.terminal.DefaultTerminalFactory;
import com.googlecode.lanterna.terminal.Terminal;
import io.manbang.easybytecoder.clientbootstrap.Loder.AgentLoader;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
/**
* @author xujie
*/
public class ViewMenu {
public void SelectPid(HashMap<String, String> pids) throws IOException {
// Setup terminal and screen layers
final Terminal terminal = new DefaultTerminalFactory().createTerminal();
final Screen screen = new TerminalScreen(terminal);
screen.startScreen();
final WindowBasedTextGUI messageDialog = new MultiWindowTextGUI(screen);
new MessageDialogBuilder()
.setTitle("easyByteCoder")
.setText("请选择进行动态字节码注入的进程")
.addButton(MessageDialogButton.OK)
.build()
.showDialog(messageDialog);
// Create panel to hold components
final Panel panel = new Panel();
panel.setLayoutManager(new GridLayout(10));
final Table<String> table = new Table<String>("进程名", "进程Pid");
for (String s : pids.keySet()) {
table.getTableModel().addRow(s, pids.get(s));
}
table.setSelectAction(new Runnable() {
@Override
public void run() {
List<String> data = table.getTableModel().getRow(table.getSelectedRow());
final WindowBasedTextGUI confirmGui = new MultiWindowTextGUI(screen);
MessageDialog confirmButton = new MessageDialogBuilder()
.setTitle("确认注入")
.setText("应用名为:" + data.get(0) + " pid为:" + data.get(1))
.addButton(MessageDialogButton.OK)
.addButton(MessageDialogButton.Cancel)
.build();
MessageDialogButton messageDialogButton = confirmButton.showDialog(confirmGui);
if ("OK".equals(messageDialogButton.name())) {
try {
screen.close();
terminal.close();
AgentLoader.start(data.get(1));
return;
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
panel.addComponent(table);
// Create window to hold the panel
BasicWindow window = new BasicWindow();
window.setComponent(panel);
// Create gui and start gui
MultiWindowTextGUI gui = new MultiWindowTextGUI(screen, new DefaultWindowManager(), new EmptySpace(TextColor.ANSI.BLUE));
gui.addWindowAndWait(window);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/agent/src/main/java/io/manbang/easybytecoder/client/Agent.java | client/agent/src/main/java/io/manbang/easybytecoder/client/Agent.java | package io.manbang.easybytecoder.client;
import io.manbang.easybytecoder.client.utils.ArgsParser;
import io.manbang.easybytecoder.client.utils.BootstrapClassLoaderFactory;
import io.manbang.easybytecoder.runtimecommonapi.utils.EasyByteCoderResourceObjectPool;
import io.manbang.easybytecoder.runtimecommonapi.utils.StringUtils;
import java.io.File;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URLClassLoader;
import java.util.Map;
import java.util.jar.JarFile;
/**
* @author GaoYang 2018/12/23
*/
public class Agent {
/**
* 制定plugin路径参数名
*/
public static final String ARHS_PLUGIN_PATH = "pluginPath";
/**
* plugin Jar包路径
*/
public static String BASE_PLUGIN_PATH;
/**
* client bootstrap实例
*/
public static volatile Object bootstrapObj;
/**
* java agent 的入口函数 会先于应用的main方法执行 主要进行了easyByteCoder空间的初始化： log初始化，各中间件plugin的初始化
* 以及设置instrument的trnsformer； 每一个类在加载进JVM 前，都会经由各plugin的transformer进行匹配修改
*/
public static void premain(String agentArgs, Instrumentation instrumentation) {
// 参数解析
Map<String, String> agentArgsMap = ArgsParser.parse(agentArgs);
// 环境准备
prepareEnv(agentArgsMap, instrumentation);
// thread context classloader 特殊处理，使easyByteCoder使用的log4j 与应用本身完全隔离互不干扰
URLClassLoader easyByteCoderLoader = BootstrapClassLoaderFactory.createBootClassLoader(BASE_PLUGIN_PATH, null);
ClassLoader originLoader = Thread.currentThread().getContextClassLoader();
try {
// 初始化easyByteCoder bootstrap 与plugin
Thread.currentThread().setContextClassLoader(easyByteCoderLoader);
// 初始化 应用与easyByteCoder的桥接类 EasyByteCoderResourceObjectPool，使用该类可以连通easyByteCoder空间与应用空间，相互访问
EasyByteCoderResourceObjectPool.init(easyByteCoderLoader);
loadAndRegisterPlugins(easyByteCoderLoader, agentArgsMap, instrumentation);
} catch (Exception e) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("ERROR: bootStrap init failed!", e);
} finally {
Thread.currentThread().setContextClassLoader(originLoader);
}
}
private static void prepareEnv(Map<String, String> agentArgsMap, Instrumentation instrumentation) {
// 1. 将当前jar包中的其他类提升到bootstrap Classloader 中进行加载
String agentJarFilePath = Agent.class.getProtectionDomain().getCodeSource().getLocation().getFile();
File agentFile = new File(agentJarFilePath);
try {
instrumentation.appendToBootstrapClassLoaderSearch(new JarFile(agentFile));
} catch (Exception e) {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().error("add to bootstrap class path error:", e);
}
// 2. 获取plugin包存放路径
BASE_PLUGIN_PATH = getPluginPath(agentArgsMap, agentFile);
}
private static String getPluginPath(Map<String, String> agentArgsMap, File agentFile) {
// 默认从args中获取
String path = agentArgsMap.get(ARHS_PLUGIN_PATH.toLowerCase());
if (StringUtils.isNotBlank(path)) {
return path;
}
// 未传入，默认认为plugin包与agent包在同一个目录下
return agentFile.getParent();
}
/**
* 加载plugin插件
*
* @param easyByteCoderClassLoader
* @param agentArgsMap
* @param instrumentation
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
private static void loadAndRegisterPlugins(URLClassLoader easyByteCoderClassLoader, Map<String, String> agentArgsMap, Instrumentation instrumentation)
throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().info("start loading plugins");
// 实例化EasyByteCoderClientBootStrap并调用init方法
Class<?> bootstrapClass = easyByteCoderClassLoader.loadClass("io.manbang.easybytecoder.clientbootstrap.EasyByteCoderClientBootStrap");
bootstrapObj = bootstrapClass.newInstance();
Method initMethod = bootstrapClass.getMethod("init", Instrumentation.class, String.class, Map.class);
// 调用init方法
initMethod.invoke(bootstrapObj, instrumentation, BASE_PLUGIN_PATH, agentArgsMap);
EasyByteCoderResourceObjectPool.getEasyByteCoderLogger().info("loading easyByteCoder plugins successfully");
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/agent/src/main/java/io/manbang/easybytecoder/client/utils/BootstrapClassLoaderFactory.java | client/agent/src/main/java/io/manbang/easybytecoder/client/utils/BootstrapClassLoaderFactory.java | package io.manbang.easybytecoder.client.utils;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
/**
* @author GaoYang 2018/12/23
*/
public class BootstrapClassLoaderFactory {
public static final String BOOTSTRAP_FILENAME = "bootstrap.jar";
public static final String COMMON_FILENAME = "common.jar";
public static URLClassLoader createBootClassLoader(String bootstrapClassPath, final ClassLoader oldLoader) {
URL[] elements = new URL[2];
File[] files = new File[2];
files[0] = new File(bootstrapClassPath + "/" + BOOTSTRAP_FILENAME);
files[1] = new File(bootstrapClassPath + "/" + COMMON_FILENAME);
for (int j = 0; j < files.length; j++) {
try {
URL element = files[j].toURI().normalize().toURL();
elements[j] = element;
} catch (MalformedURLException e) {
System.out.println("load jar file error:" + e);
}
}
return URLClassLoader.newInstance(elements, oldLoader);
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
ymm-tech/easy-byte-coder | https://github.com/ymm-tech/easy-byte-coder/blob/0f4b6abf0e066fa5ae88651893c9ce3087154439/client/agent/src/main/java/io/manbang/easybytecoder/client/utils/ArgsParser.java | client/agent/src/main/java/io/manbang/easybytecoder/client/utils/ArgsParser.java | package io.manbang.easybytecoder.client.utils;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/**
* @author GaoYang 2018/12/23
*/
public class ArgsParser {
public static Map<String, String> parse(String args) {
if (isEmpty(args)) {
return Collections.emptyMap();
}
final Map<String, String> map = new HashMap<String, String>();
Scanner scanner = new Scanner(args);
scanner.useDelimiter(":");
while (scanner.hasNext()) {
String token = scanner.next();
int assign = token.indexOf('=');
if (assign == -1) {
map.put(token.toLowerCase(), "");
} else {
String key = token.substring(0, assign);
String value = token.substring(assign + 1);
map.put(key.toLowerCase(), value);
}
}
scanner.close();
return Collections.unmodifiableMap(map);
}
private static boolean isEmpty(String args) {
return args == null || args.isEmpty();
}
}
| java | MIT | 0f4b6abf0e066fa5ae88651893c9ce3087154439 | 2026-01-05T02:40:37.457940Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/test/java/zql/app_jinnang/ExampleUnitTest.java | app/src/test/java/zql/app_jinnang/ExampleUnitTest.java | package zql.app_jinnang;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
assertEquals(4, 2 + 2);
}
} | java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/UserSetingImp.java | app/src/main/java/zql/app_jinnang/UserSetingImp.java | package zql.app_jinnang;
import java.util.List;
public interface UserSetingImp {
public void putpasswordonSeting(String password);
public String getpassswordfromSeting();
public void putquestiononSeting(String question);
public String getquestionfromSeting();
public boolean iscurrentthePassword(String password);
public boolean iscurrentthQuestion(String qusetion);
public boolean isnullthepassword();
public boolean isnullthequestion();
public void putcurrentColor(int color);
public List<Integer> getcurrentColor();
public int getcurrentColorNum();
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/UserSeting.java | app/src/main/java/zql/app_jinnang/UserSeting.java | package zql.app_jinnang;
import android.app.Application;
import android.content.SharedPreferences;
import java.util.ArrayList;
import java.util.List;
public class UserSeting extends Application implements UserSetingImp {
public SharedPreferences sharedPreferences;
@Override
public void onCreate() {
super.onCreate();
initSharedPreference();
}
private void initSharedPreference(){
sharedPreferences=getSharedPreferences("config_jinnang",MODE_PRIVATE);
SharedPreferences.Editor editor=sharedPreferences.edit();
}
@Override
public String getpassswordfromSeting() {
return sharedPreferences.getString("password","null").toString();
}
@Override
public String getquestionfromSeting() {
return sharedPreferences.getString("question","null").toString();
}
@Override
public void putpasswordonSeting(String password) {
SharedPreferences.Editor editor=sharedPreferences.edit();
editor.putString("password",password);
editor.commit();
editor.apply();
}
@Override
public void putquestiononSeting(String question) {
SharedPreferences.Editor editor=sharedPreferences.edit();
editor.putString("question",question);
editor.commit();
}
@Override
public boolean iscurrentthePassword(String password) {
if (password.equals(this.getpassswordfromSeting())){
return true;
}else {
return false;
}
}
@Override
public boolean iscurrentthQuestion(String qusetion) {
if (qusetion.equals(this.getquestionfromSeting())){
return true;
}else {
return false;
}
}
@Override
public boolean isnullthepassword() {
if (this.getpassswordfromSeting().equals("null")){
return true;
}else {
return false;
}
}
@Override
public boolean isnullthequestion() {
if (this.getquestionfromSeting().equals("null")){
return true;
}else {
return false;
}
}
@Override
public void putcurrentColor(int color) {
SharedPreferences.Editor editor=sharedPreferences.edit();
editor.putInt("color",color);
editor.commit();
}
@Override
public List<Integer> getcurrentColor() {
List<Integer> mlist=new ArrayList<>();
switch (sharedPreferences.getInt("color",0)){
case 0:
mlist.add(0,getResources().getColor(R.color.colorFloatingButton));
mlist.add(1,getResources().getColor(R.color.colorfirst));
break;
case 1:
mlist.add(0,getResources().getColor(R.color.colorFloatingButton1));
mlist.add(1,getResources().getColor(R.color.colorfirsr_1));
break;
case 2:
mlist.add(0,getResources().getColor(R.color.colorFloatingButton2));
mlist.add(1,getResources().getColor(R.color.colorfirst_2));
break;
case 3:
mlist.add(0,getResources().getColor(R.color.colorFloatingButton3));
mlist.add(1,getResources().getColor(R.color.colorfirst_3));
break;
case 4:
mlist.add(0,getResources().getColor(R.color.colorFloatingButton4));
mlist.add(1,getResources().getColor(R.color.colorfirst_4));
break;
default:
break;
}
return mlist;
}
@Override
public int getcurrentColorNum() {
return sharedPreferences.getInt("color",0);
}
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/Model/NoteInfoModelImp.java | app/src/main/java/zql/app_jinnang/Model/NoteInfoModelImp.java | package zql.app_jinnang.Model;
import android.database.Cursor;
import java.util.List;
import lecho.lib.hellocharts.model.PieChartData;
import lecho.lib.hellocharts.model.SliceValue;
import zql.app_jinnang.Bean.NoteBean;
/**
* Created by 尽途 on 2018/4/4.
*/
public interface NoteInfoModelImp {
public void InsertNotetoData(NoteBean noteBean);
public void InsertNotetoData_secret(NoteBean noteBean);
public void InsertNotetoDatabyId(NoteBean noteBean);
public void DeleteNotefromData(NoteBean noteBean);
public void DeleteNotefromData_secret(NoteBean noteBean);
public List<NoteBean> QueryAllNotefromData();
public List<NoteBean> QueryAllNotefromData_secret();
public List<NoteBean> QueryNoyefromDataByType(String READ_TYPE);
public int QueryEveryTypeSumfromDataByType(String READ_TYPE);
public int QueryAllNoteSumfromfromData();//获取创建note的总数量
public int QueryAllSecretNoteSumfromSecretData();//获取创建私密note的总数量
public List<String> QueryNotecreatetime();
public List<NoteBean> QueryNotebeanBycreatetime(String creaetime);
public void ChangeNotetoData(NoteBean noteBean);
public void DeleteNotefromDataByid(Long id);
public Cursor getCursorfromData(String search);
public List<NoteBean> getSearchfromData(String search);
public List<SliceValue> getPieChartNumberfromData();
public List<Integer> getPieChartTypeListfromData();//获取各类型数据
public boolean readDataSizeisEmpty();//判断数据库是否为空
public boolean readSecretDataisEmpty();//判断密码数据库是否为空
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/Model/NoteInfoModel.java | app/src/main/java/zql/app_jinnang/Model/NoteInfoModel.java | package zql.app_jinnang.Model;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Color;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.greendao.query.QueryBuilder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import lecho.lib.hellocharts.model.PieChartData;
import lecho.lib.hellocharts.model.SliceValue;
import zql.app_jinnang.Bean.Means;
import zql.app_jinnang.Bean.MessageEvent;
import zql.app_jinnang.Bean.NoteBean;
import zql.app_jinnang.R;
import zql.app_jinnang.greendao.db.DaoMaster;
import zql.app_jinnang.greendao.db.DaoSession;
import zql.app_jinnang.greendao.db.NoteBeanDao;
/**
* Created by 尽途 on 2018/4/4.
*/
public class NoteInfoModel implements NoteInfoModelImp {
private NoteBeanDao noteBeanDao,noteBeanDao_secret;
private SQLiteDatabase db,db_secret;
private DaoSession daoSession,daoSession_secret;
private Context mcontext;
public NoteInfoModel(Context context){
this.mcontext=context;
initGreendao();
initGreendao_serect();
}
void initGreendao(){//创建公开数据库
DaoMaster.DevOpenHelper helper=new DaoMaster.DevOpenHelper(mcontext,"recluse-db",null);
db=helper.getWritableDatabase();
DaoMaster daoMaster=new DaoMaster(db);
daoSession=daoMaster.newSession();
noteBeanDao=daoSession.getNoteBeanDao();
}
void initGreendao_serect(){//创建私密数据库
DaoMaster.DevOpenHelper helper=new DaoMaster.DevOpenHelper(mcontext,"serect-db",null);
db_secret=helper.getWritableDatabase();
DaoMaster daoMaster=new DaoMaster(db_secret);
daoSession_secret=daoMaster.newSession();
noteBeanDao_secret=daoSession_secret.getNoteBeanDao();
}
/**
* 数据库插入操作
* @param noteBean
*/
@Override
public void InsertNotetoData(NoteBean noteBean) {
noteBeanDao.insert(noteBean);
EventBus.getDefault().post(new MessageEvent(MessageEvent.UPDATE_DATA));
}
@Override
public void InsertNotetoData_secret(NoteBean noteBean) {
if (noteBean.getId()!=null){
noteBean.setId(null);
}
noteBeanDao_secret.insert(noteBean);
EventBus.getDefault().post(new MessageEvent(MessageEvent.UPDATE_DATA));
}
@Override
public void InsertNotetoDatabyId(NoteBean noteBean) {
if (noteBean.getId()!=null){
// noteBeanDao.update(noteBean);
noteBeanDao.refresh(noteBean);
EventBus.getDefault().post(new MessageEvent(MessageEvent.UPDATE_DATA));
}
}
/**
* 数据库删除操作
* @param noteBean
*/
@Override
public void DeleteNotefromData(NoteBean noteBean) {
noteBeanDao.delete(noteBean);
EventBus.getDefault().post(new MessageEvent(MessageEvent.UPDATE_DATA));
}
@Override
public void DeleteNotefromData_secret(NoteBean noteBean) {
noteBeanDao_secret.delete(noteBean);
}
@Override
public void ChangeNotetoData(NoteBean noteBean) {
if (noteBean.getId()!=null){
DeleteNotefromDataByid(noteBean.getId());
noteBeanDao.insert(noteBean);
EventBus.getDefault().post(new MessageEvent(MessageEvent.UPDATE_DATA));
}
}
@Override
public List<String> QueryNotecreatetime() {//获取创建时间的列表
List<NoteBean> mlist=noteBeanDao.loadAll();
List<String> slist=new ArrayList<>();
for (int i=0;i<mlist.size();i++){
slist.add(mlist.get(i).getCreatetime().toString());
}
return Means.removeDuplicate(slist);//去除重复的元素
}
@Override//通过创建时间查询
public List<NoteBean> QueryNotebeanBycreatetime(String creaetime) {
QueryBuilder<NoteBean> queryBuilder=noteBeanDao.queryBuilder();
queryBuilder.where(NoteBeanDao.Properties.Createtime.like(creaetime))
.orderAsc(NoteBeanDao.Properties.Createtime);
return queryBuilder.list();
}
@Override
public List<NoteBean> QueryAllNotefromData() {
daoSession.clear();
noteBeanDao.detachAll();
List mlist=noteBeanDao.loadAll();
Collections.reverse(mlist);//倒序
return mlist;
}
@Override
public List<NoteBean> QueryAllNotefromData_secret() {
List mlist=noteBeanDao_secret.loadAll();
Collections.reverse(mlist);
return mlist;
}
@Override
public Cursor getCursorfromData(String search) {
Cursor cursor=null;
return cursor;
}
@Override
public void DeleteNotefromDataByid(Long id) {
noteBeanDao.deleteByKey(id);
}
@Override
public List<NoteBean> getSearchfromData(String search) {
QueryBuilder<NoteBean> queryBuilder=noteBeanDao.queryBuilder();
queryBuilder.where(NoteBeanDao.Properties.Noteinfo.like("%"+search+"%"))
.orderAsc(NoteBeanDao.Properties.Noteinfo);
return queryBuilder.list();
}
@Override
public List<NoteBean> QueryNoyefromDataByType(String READ_TYPE) {
QueryBuilder<NoteBean> queryBuilder=noteBeanDao.queryBuilder();
queryBuilder.where(NoteBeanDao.Properties.Notetype.like(READ_TYPE))
.orderAsc(NoteBeanDao.Properties.Notetype);
List list=queryBuilder.list();
Collections.reverse(list);//倒序
return list;
}
@Override
public int QueryAllNoteSumfromfromData() {
List mlist=noteBeanDao.loadAll();
return mlist.size();
}
@Override
public int QueryAllSecretNoteSumfromSecretData() {
List mlist=noteBeanDao_secret.loadAll();
return mlist.size();
}
@Override
public int QueryEveryTypeSumfromDataByType(String READ_TYPE) {
QueryBuilder<NoteBean> queryBuilder=noteBeanDao.queryBuilder();
queryBuilder.where(NoteBeanDao.Properties.Notetype.like(READ_TYPE))
.orderAsc(NoteBeanDao.Properties.Notetype);
List list=queryBuilder.list();
return list.size();
}
@Override
public List<Integer> getPieChartTypeListfromData() {
List<String> types=new ArrayList<>();
List<Integer> list=new ArrayList<>();
types.add(0,"工作");
types.add(1,"学习");
types.add(2,"生活");
types.add(3,"日记");
types.add(4,"旅行");
for (int i=0;i<5;i++){
list.add(i,QueryEveryTypeSumfromDataByType(types.get(i)));
}
return list;
}
@Override
public List<SliceValue> getPieChartNumberfromData() {//获取饼状图的数据
List<SliceValue>mlist=new ArrayList<>();
List<Integer> colors=new ArrayList<>();
List<String> types=new ArrayList<>();
types.add(0,"生活");
types.add(1,"工作");
types.add(2,"学习");
types.add(3,"日记");
types.add(4,"旅行");
colors.add(0,R.color.colorlive);
colors.add(1,R.color.colorwork);
colors.add(2,R.color.colorstudy);
colors.add(3,R.color.colordiary);
colors.add(4,R.color.colortravel);
for (int i=0;i<5;i++){
SliceValue sliceValue=new SliceValue();
sliceValue.setColor(colors.get(i));
sliceValue.setLabel(types.get(i));
sliceValue.setValue(QueryEveryTypeSumfromDataByType(types.get(i)));
}
return mlist;
}
@Override
public boolean readDataSizeisEmpty() {
if (QueryAllNoteSumfromfromData()==0){
return true;
}else {
return false;
}
}
@Override
public boolean readSecretDataisEmpty() {
if (QueryAllSecretNoteSumfromSecretData()==0){
return true;
}else {
return false;
}
}
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/Adapter/RecyclerViewSearchAdapter.java | app/src/main/java/zql/app_jinnang/Adapter/RecyclerViewSearchAdapter.java | package zql.app_jinnang.Adapter;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.RelativeLayout;
import android.widget.SearchView;
import android.widget.SearchView.OnQueryTextListener;
import android.widget.TextView;
import java.util.List;
import zql.app_jinnang.Bean.Means;
import zql.app_jinnang.Bean.NoteBean;
import zql.app_jinnang.R;
import zql.app_jinnang.View.NoteinfoActivity;
/**
* Created by 尽途 on 2018/5/3.
*/
public class RecyclerViewSearchAdapter extends RecyclerView.Adapter<RecyclerViewSearchAdapter.Viewholder>{
private List<NoteBean>notelist;
private Context context;
public RecyclerViewSearchAdapter(List<NoteBean> mnotelist, Context mcontext){
this.notelist=mnotelist;
this.context=mcontext;
}
@Override
public Viewholder onCreateViewHolder(ViewGroup parent, int viewType) {
View item_search= LayoutInflater.from(parent.getContext()).inflate(R.layout.item_suggestioncard,parent,false);
Viewholder viewholder=new Viewholder(item_search);
return viewholder;
}
@Override
public void onBindViewHolder(Viewholder holder, int position) {
startNoteinfoActivity(holder.relativeLayout,notelist.get(position));
holder.recycler_text_note.setText(Means.getNotetextOnSearchCard(notelist.get(position).getNoteinfo().toString()));
}
@Override
public int getItemCount() {
return notelist==null?0:notelist.size();
}
public class Viewholder extends RecyclerView.ViewHolder{
TextView recycler_text_note;
RelativeLayout relativeLayout;
public Viewholder(View itemView){
super(itemView);
recycler_text_note=(TextView)itemView.findViewById(R.id.textview_item_suggestion);
relativeLayout=(RelativeLayout)itemView.findViewById(R.id.rela_suggestion);
}
}
private void startNoteinfoActivity(View view,final NoteBean noteBean){
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent mintent=new Intent(context,NoteinfoActivity.class);
Bundle bundle=new Bundle();
bundle.putSerializable("noteinfo", Means.changefromNotebean(noteBean));
mintent.putExtras(bundle);
context.startActivity(mintent);
}
});
}
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/Adapter/RecyclerViewCardAdapter.java | app/src/main/java/zql/app_jinnang/Adapter/RecyclerViewCardAdapter.java | package zql.app_jinnang.Adapter;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.util.ArrayList;
import zql.app_jinnang.Bean.Means;
import zql.app_jinnang.Bean.NoteBean;
import zql.app_jinnang.R;
import zql.app_jinnang.UserSeting;
import zql.app_jinnang.View.ListActivityImp;
import zql.app_jinnang.View.NoteinfoActivity;
/**
* Created by 尽途 on 2018/4/12.
*/
public class RecyclerViewCardAdapter extends RecyclerView.Adapter<RecyclerViewCardAdapter.Viewholder> {
private ArrayList<NoteBean>notelist;
private Context context;
private ListActivityImp listActivityImp;
/**
* 空数据时，显示空布局类型
*/
private final int EMPTY_VIEW = 1;
/**
* 控制空布局的显隐
*/
private int mEmptyType = 0;
public RecyclerViewCardAdapter(ArrayList<NoteBean>mnotelist,Context mcontext,ListActivityImp mlistactivityimp){
this.notelist=mnotelist;
this.context=mcontext;
this.listActivityImp=mlistactivityimp;
}
@Override
public Viewholder onCreateViewHolder(ViewGroup parent, int viewType) {
View iten_recycler= LayoutInflater.from(parent.getContext()).inflate(R.layout.item_recyclercard,parent,false);
Viewholder viewholder=new Viewholder(iten_recycler);
return viewholder;
}
@Override
public void onBindViewHolder(Viewholder holder, int position) {
int itemViewType=getItemViewType(position);
if (EMPTY_VIEW!=itemViewType){
}
setMenuListener(holder.recycler_image_menu,notelist.get(position));
switch (notelist.get(position).getNotetype().toString()){
case "旅行":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_travel);
holder.recycler_text_note.setText(R.string.note_travel);
break;
case "学习":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_study);
holder.recycler_text_note.setText(R.string.note_study);
break;
case "工作":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_work);
holder.recycler_text_note.setText(R.string.note_work);
break;
case "日记":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_diary);
holder.recycler_text_note.setText(R.string.note_diary);
break;
case "生活":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_live);
holder.recycler_text_note.setText(R.string.note_live);
break;
default:
break;
}
holder.recycler_text_note.setText(Means.getNotetextOnRecyclerCard(notelist.get(position).getNoteinfo()));
holder.recycler_text_time.setText(notelist.get(position).getCreatetime());
startNoteinfoActivity(holder.linearLayout,notelist.get(position));
}
@Override
public int getItemCount() {
return notelist==null ? 0 : notelist.size();
}
public static class Viewholder extends RecyclerView.ViewHolder{
ImageView recycler_image_notetype,recycler_image_menu;
TextView recycler_text_note,recycler_text_time;
LinearLayout linearLayout;
public Viewholder(View itemView){
super(itemView);
recycler_image_notetype=(ImageView)itemView.findViewById(R.id.recycler_image_notetype);
recycler_image_menu=(ImageView)itemView.findViewById(R.id.recycler_image_menu);
recycler_text_note=(TextView)itemView.findViewById(R.id.recycler_text_note);
recycler_text_time=(TextView)itemView.findViewById(R.id.recycler_text_time);
linearLayout=(LinearLayout)itemView.findViewById(R.id.recycler_item);
}
}
public static class EmptyViewholder extends RecyclerView.ViewHolder{
public EmptyViewholder(View emptyView){
super(emptyView);
}
}
private void setMenuListener(View view, final NoteBean noteBean){
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
listActivityImp.opensheeetdialog(noteBean);
}
});
}
private void startNoteinfoActivity(View view,final NoteBean noteBean){
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent mintent=new Intent(listActivityImp.getListActivityConent(),NoteinfoActivity.class);
Bundle bundle=new Bundle();
bundle.putSerializable("noteinfo", Means.changefromNotebean(noteBean));
mintent.putExtras(bundle);
context.startActivity(mintent);
}
});
}
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/Adapter/RecyclerViewSecretCardAdapter.java | app/src/main/java/zql/app_jinnang/Adapter/RecyclerViewSecretCardAdapter.java | package zql.app_jinnang.Adapter;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.util.ArrayList;
import zql.app_jinnang.Bean.Means;
import zql.app_jinnang.Bean.NoteBean;
import zql.app_jinnang.R;
import zql.app_jinnang.UserSeting;
import zql.app_jinnang.View.ListSecretActivityImp;
import zql.app_jinnang.View.NoteinfoActivity;
public class RecyclerViewSecretCardAdapter extends RecyclerView.Adapter<RecyclerViewSecretCardAdapter.Viewholder>{
private ArrayList<NoteBean>notelist;
private Context context;
private ListSecretActivityImp listSecretActivityImp;
public RecyclerViewSecretCardAdapter(ArrayList<NoteBean>mnotelist,Context mcontext,ListSecretActivityImp mlistSecretActivityImp){
this.notelist=mnotelist;
this.context=mcontext;
this.listSecretActivityImp=mlistSecretActivityImp;
}
@Override
public Viewholder onCreateViewHolder(ViewGroup parent, int viewType) {
View item_recycler=LayoutInflater.from(parent.getContext()).inflate(R.layout.item_recyclercard,parent,false);
Viewholder viewholder=new Viewholder(item_recycler);
return viewholder;
}
@Override
public void onBindViewHolder(Viewholder holder, int position) {
setMenuListener(holder.recycler_image_menu,notelist.get(position));
switch (notelist.get(position).getNotetype().toString()){
case "旅行":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_travel);
holder.recycler_text_note.setText(R.string.note_travel);
break;
case "学习":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_study);
holder.recycler_text_note.setText(R.string.note_study);
break;
case "工作":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_work);
holder.recycler_text_note.setText(R.string.note_work);
break;
case "日记":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_diary);
holder.recycler_text_note.setText(R.string.note_diary);
break;
case "生活":
holder.recycler_image_notetype.setImageResource(R.drawable.icon_live);
holder.recycler_text_note.setText(R.string.note_live);
break;
default:
break;
}
holder.recycler_text_note.setText(Means.getNotetextOnRecyclerCard(notelist.get(position).getNoteinfo()));
holder.recycler_text_time.setText(notelist.get(position).getCreatetime());
startNoteinfoActivity(holder.linearLayout,notelist.get(position));
}
@Override
public int getItemCount() {
return notelist==null ? 0 : notelist.size();
}
public class Viewholder extends RecyclerView.ViewHolder{
LinearLayout linearLayout;
ImageView recycler_image_notetype,recycler_image_menu;
TextView recycler_text_note,recycler_text_time;
public Viewholder(View itemView){
super(itemView);
recycler_image_notetype=(ImageView)itemView.findViewById(R.id.recycler_image_notetype);
recycler_image_menu=(ImageView)itemView.findViewById(R.id.recycler_image_menu);
recycler_text_note=(TextView)itemView.findViewById(R.id.recycler_text_note);
recycler_text_time=(TextView)itemView.findViewById(R.id.recycler_text_time);
linearLayout=(LinearLayout)itemView.findViewById(R.id.recycler_item);
}
}
private void setMenuListener(View view, final NoteBean noteBean){
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
listSecretActivityImp.opensheetdialog(noteBean);
}
});
}
private void startNoteinfoActivity(View view,final NoteBean noteBean){
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent mintent=new Intent(listSecretActivityImp.getListSerectActivityContext(),NoteinfoActivity.class);
Bundle bundle=new Bundle();
bundle.putSerializable("noteinfo", Means.changefromNotebean(noteBean));
mintent.putExtras(bundle);
context.startActivity(mintent);
}
});
}
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
zqljintu/Memory-capsule | https://github.com/zqljintu/Memory-capsule/blob/b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7/app/src/main/java/zql/app_jinnang/Adapter/ViewPagerCardAdapter.java | app/src/main/java/zql/app_jinnang/Adapter/ViewPagerCardAdapter.java | package zql.app_jinnang.Adapter;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.view.PagerAdapter;
import android.support.v7.app.AlertDialog;
import android.support.v7.widget.CardView;
import android.support.v7.widget.LinearSmoothScroller;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import java.util.ArrayList;
import java.util.List;
import zql.app_jinnang.Bean.Means;
import zql.app_jinnang.Bean.NoteBean;
import zql.app_jinnang.Prestener.PrestenerImp_main;
import zql.app_jinnang.R;
import zql.app_jinnang.UserSeting;
import zql.app_jinnang.View.MainActivityImp;
import zql.app_jinnang.View.NoteinfoActivity;
/**
* Created by 尽途 on 2018/4/8.
*/
public class ViewPagerCardAdapter extends PagerAdapter {
private View currentView;
private MainActivityImp mainActivityImp;
public static ImageView menu_item_viewpagercard;
private ImageView imageview_item_viewpagercard,lableview_item_viewpagercard;
private TextView textview_item_viewpagercard,createtime_item_viewpagercard;
private CardView viewpager_card;
private List<NoteBean>list;
private Context context;
private LayoutInflater layoutInflater;
private PrestenerImp_main prestenerImp_main;
private int mChildCount = 0;
public ViewPagerCardAdapter(Context mcontext,List<NoteBean>mlist,MainActivityImp mmainActivityImp,PrestenerImp_main mprestenerImp_main){
this.context=mcontext;
this.list=mlist;
this.mainActivityImp=mmainActivityImp;
this.prestenerImp_main=mprestenerImp_main;
layoutInflater=LayoutInflater.from(context);
}
@Override
public int getCount() {
return list.size();
}
@Override
public boolean isViewFromObject(View view, Object object) {
return view==object;
}
@Override
public void setPrimaryItem(ViewGroup container, int position, Object object) {
currentView=(View)object;
super.setPrimaryItem(container, position, object);
}
@Override
public Object instantiateItem(ViewGroup container, int position) {
String type=list.get(position).getNotetype().toString();
String noteinfo=list.get(position).getNoteinfo().toString();
String photopath=list.get(position).getPhotopath().toString();
String createtime=list.get(position).getCreatetime().toString();
View view=layoutInflater.inflate(R.layout.item_viewpagercard,container,false);
imageview_item_viewpagercard=(ImageView)view.findViewById(R.id.imageview_item_viewpagercard);
lableview_item_viewpagercard=(ImageView)view.findViewById(R.id.lableview_item_viewpagercard);
menu_item_viewpagercard=(ImageView)view.findViewById(R.id.menu_item_viewpagercard);
textview_item_viewpagercard=(TextView)view.findViewById(R.id.textview_item_viewpagercard);
createtime_item_viewpagercard=(TextView)view.findViewById(R.id.createtime_item_viewpagercard);
viewpager_card=(CardView)view.findViewById(R.id.viewPager_card);
setMenuListener(menu_item_viewpagercard,list.get(position));
startNoteinfoActivity(viewpager_card,list.get(position));
textview_item_viewpagercard.setText(Means.getNotetextOnViewPagerCard(noteinfo));
createtime_item_viewpagercard.setText("——创建于:"+createtime);
if (photopath.equals("<图片>")||photopath.equals("null")){
imageview_item_viewpagercard.setScaleType(ImageView.ScaleType.FIT_CENTER);
}else {
imageview_item_viewpagercard.setScaleType(ImageView.ScaleType.CENTER_CROP);
}
readNoteonMainbyNotetype(lableview_item_viewpagercard);
/**
* 早期开发留下的弊端，必须满足老版本，所以添加photopath.equals("<图片>")||photopath.equals("null")两种状态判断条件
*/
switch (type){
case "生活":
lableview_item_viewpagercard.setImageResource(R.drawable.icon_live);
if (photopath.equals("<图片>")||photopath.equals("null")){
imageview_item_viewpagercard.setImageResource(R.drawable.photo_live);
}else {
Glide.with(mainActivityImp.getActivity_this()).load(photopath).into(imageview_item_viewpagercard);
}
break;
case "工作":
lableview_item_viewpagercard.setImageResource(R.drawable.icon_work);
if (photopath.equals("<图片>")||photopath.equals("null")){
imageview_item_viewpagercard.setImageResource(R.drawable.photo_work);
}else {
Glide.with(mainActivityImp.getActivity_this()).load(photopath).into(imageview_item_viewpagercard);
}
break;
case "日记":
lableview_item_viewpagercard.setImageResource(R.drawable.icon_diary);
if (photopath.equals("<图片>")||photopath.equals("null")){
imageview_item_viewpagercard.setImageResource(R.drawable.photo_dilary);
}else {
Glide.with(mainActivityImp.getActivity_this()).load(photopath).into(imageview_item_viewpagercard);
}
break;
case "学习":
lableview_item_viewpagercard.setImageResource(R.drawable.icon_study);
if (photopath.equals("<图片>")||photopath.equals("null")){
imageview_item_viewpagercard.setImageResource(R.drawable.photo_study);
}else {
Glide.with(mainActivityImp.getActivity_this()).load(photopath).into(imageview_item_viewpagercard);
}
break;
case "旅行":
lableview_item_viewpagercard.setImageResource(R.drawable.icon_travel);
if (photopath.equals("<图片>")||photopath.equals("null")){
imageview_item_viewpagercard.setImageResource(R.drawable.photo_travel);
}else {
Glide.with(mainActivityImp.getActivity_this()).load(photopath).into(imageview_item_viewpagercard);
}
break;
default:
break;
}
container.addView(view);
return view;
}
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
container.removeView((View)object);
}
private void setMenuListener(View view, final NoteBean noteBean){//对相应的按钮进行监听
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
mainActivityImp.openSheetDialog(noteBean);
}
});
}
private void readNoteonMainbyNotetype(View view){//通过标签来浏览信息
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
openTypeDilog();
}
});
}
private void openTypeDilog(){
AlertDialog.Builder builder=new AlertDialog.Builder(context);
LayoutInflater layoutInflater=LayoutInflater.from(context);
View centerview=layoutInflater.inflate(R.layout.dialog_main_type,null);
final AlertDialog alertDialog=builder.setView(centerview).create();
final LinearLayout add_dialog_typr_all,add_dialog_type_work,add_dialog_type_study,add_dialog_type_live,add_dialog_type_diary,add_dialog_type_travel;
add_dialog_typr_all=(LinearLayout)centerview.findViewById(R.id.main_dialog_typenote_all);
add_dialog_type_work=(LinearLayout)centerview.findViewById(R.id.main_dialog_typenote_work);
add_dialog_type_diary=(LinearLayout)centerview.findViewById(R.id.main_dialog_typenote_diary);
add_dialog_type_live=(LinearLayout)centerview.findViewById(R.id.main_dialog_typenote_live);
add_dialog_type_study=(LinearLayout)centerview.findViewById(R.id.main_dialog_typenote_study);
add_dialog_type_travel=(LinearLayout)centerview.findViewById(R.id.main_dialog_typenote_travel);
add_dialog_typr_all.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
prestenerImp_main.readNotefromDtabyType(0);
alertDialog.dismiss();
}
});
add_dialog_type_work.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
prestenerImp_main.readNotefromDtabyType(1);//调用接口实现标签加载
alertDialog.dismiss();
}
});
add_dialog_type_study.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
prestenerImp_main.readNotefromDtabyType(2);//调用接口实现标签加载
alertDialog.dismiss();
}
});
add_dialog_type_live.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
prestenerImp_main.readNotefromDtabyType(3);//调用接口实现标签加载
alertDialog.dismiss();
}
});
add_dialog_type_diary.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
prestenerImp_main.readNotefromDtabyType(4);//调用接口实现标签加载
alertDialog.dismiss();
}
});
add_dialog_type_travel.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
prestenerImp_main.readNotefromDtabyType(5);//调用接口实现标签加载
alertDialog.dismiss();
}
});
alertDialog.show();
}
private void startNoteinfoActivity(View view,final NoteBean noteBean){
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent mintent=new Intent(mainActivityImp.getActivity_this(),NoteinfoActivity.class);
Bundle bundle=new Bundle();
bundle.putSerializable("noteinfo", Means.changefromNotebean(noteBean));
mintent.putExtras(bundle);
context.startActivity(mintent);
}
});
}
public View getPrimaryItem(){
return currentView;
}
@Override
public void notifyDataSetChanged() {
mChildCount = getCount();
super.notifyDataSetChanged();
}
@Override
public int getItemPosition(Object object) {
if (mChildCount > 0) {
mChildCount--;
return POSITION_NONE;
}
return super.getItemPosition(object);
}
}
| java | Apache-2.0 | b06bfb26e86385f5966bb1f35f03b5cc3c4a80a7 | 2026-01-05T02:40:11.771084Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.