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 |
|---|---|---|---|---|---|---|---|---|
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/notify/catalog/CatalogNotifyHandler.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/notify/catalog/CatalogNotifyHandler.java | package io.github.lunasaw.gbproxy.server.transmit.request.notify.catalog;
import javax.sip.RequestEvent;
import io.github.lunasaw.gbproxy.server.transmit.request.notify.ServerNotifyProcessorHandler;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.service.ServerDeviceSupplier;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceOtherUpdateNotify;
import io.github.lunasaw.gbproxy.server.transmit.request.notify.NotifyServerHandlerAbstract;
import io.github.lunasaw.gbproxy.server.transmit.request.notify.ServerNotifyRequestProcessor;
import io.github.lunasaw.sip.common.entity.DeviceSession;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* @author luna
* @date 2023/10/19
*/
@Component
@Slf4j
@Getter
@Setter
public class CatalogNotifyHandler extends NotifyServerHandlerAbstract {
public static final String CMD_TYPE = "Catalog";
public CatalogNotifyHandler(ServerDeviceSupplier serverDeviceSupplier, @Lazy ServerNotifyProcessorHandler serverNotifyProcessorHandler) {
super(serverDeviceSupplier, serverNotifyProcessorHandler);
}
@Override
public void handForEvt(RequestEvent event) {
DeviceSession deviceSession = getDeviceSession(event);
String userId = deviceSession.getUserId();
Device device = serverDeviceSupplier.getDevice(userId);
if (device == null) {
// 未注册的设备不做处理
return;
}
DeviceOtherUpdateNotify deviceOtherUpdateNotify = parseXml(DeviceOtherUpdateNotify.class);
serverNotifyProcessorHandler.deviceNotifyUpdate(userId, deviceOtherUpdateNotify);
}
@Override
public String getCmdType() {
return CMD_TYPE;
}
@Override
public String getRootType() {
return ServerNotifyRequestProcessor.METHOD + RESPONSE;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/ServerRegisterProcessorHandler.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/ServerRegisterProcessorHandler.java | package io.github.lunasaw.gbproxy.server.transmit.request.register;
import io.github.lunasaw.sip.common.entity.SipTransaction;
import javax.sip.RequestEvent;
/**
* Server模块REGISTER请求处理器业务接口
* 负责具体的注册业务逻辑实现
*
* @author luna
*/
public interface ServerRegisterProcessorHandler {
/**
* 处理401未授权响应
*
* @param userId 用户ID
* @param evt 请求事件
*/
default void handleUnauthorized(String userId, RequestEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
/**
* 获取设备事务信息
*
* @param userId 用户ID
* @return 事务信息
*/
default SipTransaction getDeviceTransaction(String userId) {
return null;
}
/**
* 处理注册信息更新
*
* @param userId 用户ID
* @param registerInfo 注册信息
* @param evt 请求事件
*/
default void handleRegisterInfoUpdate(String userId, RegisterInfo registerInfo, RequestEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
/**
* 处理SIP事务更新 - 设备上线
*
* @param userId 用户ID
* @param sipTransaction SIP事务
* @param evt 请求事件
*/
default void handleDeviceOnline(String userId, SipTransaction sipTransaction, RequestEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
/**
* 处理设备下线
*
* @param userId 用户ID
* @param registerInfo 注册信息
* @param sipTransaction SIP事务
* @param evt 请求事件
*/
default void handleDeviceOffline(String userId, RegisterInfo registerInfo, SipTransaction sipTransaction, RequestEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
/**
* 获取设备过期时间
*
* @param userId 用户ID
* @return 过期时间（秒）
*/
default Integer getDeviceExpire(String userId) {
return 3600; // 默认1小时
}
/**
* 验证密码
*
* @param userId 用户ID
* @param password 密码
* @param evt 请求事件
* @return 是否验证成功
*/
default boolean validatePassword(String userId, String password, RequestEvent evt) {
return true; // 默认验证成功
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/RegisterInfo.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/RegisterInfo.java | package io.github.lunasaw.gbproxy.server.transmit.request.register;
import lombok.Data;
import java.util.Date;
/**
* @author luna
* @date 2023/10/18
*/
@Data
public class RegisterInfo {
/**
* 注册时间
*/
private Date registerTime;
/**
* 注册过期时间
*/
private Integer expire;
/**
* 注册协议
*/
private String transport;
/**
* 设备注册地址当前IP
*/
private String localIp;
/**
* nat转换后看到的IP
*/
private String remoteIp;
/**
* 经过rpotocol转换后的端口
*/
private Integer remotePort;
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/ServerRegisterRequestProcessor.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/ServerRegisterRequestProcessor.java | package io.github.lunasaw.gbproxy.server.transmit.request.register;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import javax.sip.RequestEvent;
import javax.sip.header.*;
import javax.sip.message.Request;
import javax.sip.message.Response;
import org.assertj.core.util.Lists;
import org.springframework.stereotype.Component;
import com.luna.common.date.DateUtils;
import gov.nist.javax.sip.header.SIPDateHeader;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.gbproxy.server.transmit.request.ServerAbstractSipRequestProcessor;
import io.github.lunasaw.sip.common.entity.GbSipDate;
import io.github.lunasaw.sip.common.entity.RemoteAddressInfo;
import io.github.lunasaw.sip.common.entity.SipTransaction;
import io.github.lunasaw.sip.common.transmit.ResponseCmd;
import io.github.lunasaw.sip.common.utils.SipRequestUtils;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* Server模块REGISTER请求处理器
* 只负责SIP协议层面的处理，业务逻辑通过ServerRegisterProcessorHandler接口实现
*
* @author luna
*/
@Getter
@Setter
@Component("serverRegisterRequestProcessor")
@Slf4j
public class ServerRegisterRequestProcessor extends ServerAbstractSipRequestProcessor {
public static final String METHOD = "REGISTER";
private String method = METHOD;
@Autowired
@Lazy
private ServerRegisterProcessorHandler serverRegisterProcessorHandler;
/**
* 处理REGISTER请求
* 只负责SIP协议层面的处理，业务逻辑通过ServerRegisterProcessorHandler接口实现
*
* @param evt 请求事件
*/
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest)evt.getRequest();
// 解析协议层面的信息
int expires = request.getExpires().getExpires();
boolean isRegister = expires > 0;
String userId = SipUtils.getUserIdFromFromHeader(request);
log.debug("处理{}请求：用户ID = {}, 过期时间 = {}", isRegister ? "注册" : "注销", userId, expires);
// 构建注册信息
RegisterInfo registerInfo = buildRegisterInfo(request, expires);
SipTransaction sipTransaction = SipUtils.getSipTransaction(request);
// 处理注销请求
if (!isRegister) {
serverRegisterProcessorHandler.handleDeviceOffline(userId, registerInfo, sipTransaction, evt);
return;
}
// 处理注册请求
processRegisterRequest(evt, request, userId, registerInfo, sipTransaction);
} catch (Exception e) {
log.error("处理REGISTER请求异常：evt = {}", evt, e);
}
}
/**
* 处理注册请求
*/
private void processRegisterRequest(RequestEvent evt, SIPRequest request, String userId, RegisterInfo registerInfo, SipTransaction sipTransaction) {
// 检查是否为续订请求
SipTransaction existingTransaction = serverRegisterProcessorHandler.getDeviceTransaction(userId);
String callId = SipUtils.getCallId(request);
if (existingTransaction != null && callId.equals(existingTransaction.getCallId())) {
// 续订请求，直接响应成功
List<Header> okHeaderList = getRegisterOkHeaderList(request);
ResponseCmd.doResponseCmd(Response.OK, "OK", evt, okHeaderList);
serverRegisterProcessorHandler.handleDeviceOnline(userId, sipTransaction, evt);
return;
}
// 处理首次注册认证
AuthorizationHeader authHead = (AuthorizationHeader) request.getHeader(AuthorizationHeader.NAME);
if (authHead == null) {
// 发送401认证挑战
sendAuthChallenge(evt, userId);
return;
}
// 验证密码
if (!serverRegisterProcessorHandler.validatePassword(userId, extractPassword(request), evt)) {
// 密码验证失败，返回403
log.warn("REGISTER请求密码验证失败：用户ID = {}", userId);
ResponseCmd.doResponseCmd(Response.FORBIDDEN, "wrong password", evt);
return;
}
// 注册成功
List<Header> okHeaderList = getRegisterOkHeaderList(request);
ResponseCmd.doResponseCmd(Response.OK, "OK", evt, okHeaderList);
serverRegisterProcessorHandler.handleRegisterInfoUpdate(userId, registerInfo, evt);
serverRegisterProcessorHandler.handleDeviceOnline(userId, sipTransaction, evt);
}
/**
* 发送认证挑战
*/
private void sendAuthChallenge(RequestEvent evt, String userId) {
try {
String nonce = DigestServerAuthenticationHelper.generateNonce();
WWWAuthenticateHeader wwwAuthenticateHeader =
SipRequestUtils.createWWWAuthenticateHeader(DigestServerAuthenticationHelper.DEFAULT_SCHEME,
"3402000000", nonce, DigestServerAuthenticationHelper.DEFAULT_ALGORITHM);
ResponseCmd.doResponseCmd(Response.UNAUTHORIZED, "Unauthorized", evt, wwwAuthenticateHeader);
serverRegisterProcessorHandler.handleUnauthorized(userId, evt);
} catch (Exception e) {
log.error("发送认证挑战失败：用户ID = {}", userId, e);
}
}
/**
* 从请求中提取密码信息
*/
private String extractPassword(SIPRequest request) {
// 这里可以从请求中提取密码相关信息
// 具体实现根据实际需求确定
return "";
}
/**
* 构建注册信息
*/
private RegisterInfo buildRegisterInfo(SIPRequest request, int expires) {
RegisterInfo registerInfo = new RegisterInfo();
registerInfo.setExpire(expires);
registerInfo.setRegisterTime(DateUtils.getCurrentDate());
// 获取传输协议
ViaHeader reqViaHeader = (ViaHeader) request.getHeader(ViaHeader.NAME);
String transport = reqViaHeader.getTransport();
registerInfo.setTransport("TCP".equalsIgnoreCase(transport) ? "TCP" : "UDP");
// 获取地址信息
String receiveIp = request.getLocalAddress().getHostAddress();
RemoteAddressInfo remoteAddressInfo = SipUtils.getRemoteAddressFromRequest(request);
registerInfo.setLocalIp(receiveIp);
registerInfo.setRemotePort(remoteAddressInfo.getPort());
registerInfo.setRemoteIp(remoteAddressInfo.getIp());
return registerInfo;
}
private List<Header> getRegisterOkHeaderList(Request request) {
List<Header> list = Lists.newArrayList();
// 添加date头
SIPDateHeader dateHeader = new SIPDateHeader();
// 使用自己修改的
GbSipDate gbSipDate = new GbSipDate(Calendar.getInstance(Locale.ENGLISH).getTimeInMillis());
dateHeader.setDate(gbSipDate);
list.add(dateHeader);
// 添加Contact头
list.add(request.getHeader(ContactHeader.NAME));
// 添加Expires头
list.add(request.getExpires());
return list;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/DefaultServerRegisterProcessorHandler.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/DefaultServerRegisterProcessorHandler.java | package io.github.lunasaw.gbproxy.server.transmit.request.register;
import io.github.lunasaw.sip.common.entity.SipTransaction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
/**
* Server模块REGISTER请求处理器业务接口默认实现
*
* @author luna
*/
@Slf4j
@Component
@ConditionalOnMissingBean(ServerRegisterProcessorHandler.class)
public class DefaultServerRegisterProcessorHandler implements ServerRegisterProcessorHandler {
@Override
public void handleUnauthorized(String userId, RequestEvent evt) {
log.debug("默认处理401未授权响应：用户ID = {}", userId);
}
@Override
public SipTransaction getDeviceTransaction(String userId) {
log.debug("默认获取设备事务信息：用户ID = {}", userId);
return null;
}
@Override
public void handleRegisterInfoUpdate(String userId, RegisterInfo registerInfo, RequestEvent evt) {
log.debug("默认处理注册信息更新：用户ID = {}, 注册信息 = {}", userId, registerInfo);
}
@Override
public void handleDeviceOnline(String userId, SipTransaction sipTransaction, RequestEvent evt) {
log.debug("默认处理设备上线：用户ID = {}, 事务 = {}", userId, sipTransaction);
}
@Override
public void handleDeviceOffline(String userId, RegisterInfo registerInfo, SipTransaction sipTransaction, RequestEvent evt) {
log.debug("默认处理设备下线：用户ID = {}, 注册信息 = {}, 事务 = {}", userId, registerInfo, sipTransaction);
}
@Override
public Integer getDeviceExpire(String userId) {
log.debug("默认获取设备过期时间：用户ID = {}", userId);
return 3600;
}
@Override
public boolean validatePassword(String userId, String password, RequestEvent evt) {
log.debug("默认验证密码：用户ID = {}", userId);
return true;
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/DigestServerAuthenticationHelper.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/register/DigestServerAuthenticationHelper.java | /*
* Conditions Of Use
*
* This software was developed by employees of the National Institute of
* Standards and Technology (NIST), an agency of the Federal Government.
* Pursuant to title 15 Untied States Code Section 105, works of NIST
* employees are not subject to copyright protection in the United States
* and are considered to be in the public domain. As a result, a formal
* license is not needed to use the software.
*
* This software is provided by NIST as a service and is expressly
* provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
* AND DATA ACCURACY. NIST does not warrant or make any representations
* regarding the use of the software or the results thereof, including but
* not limited to the correctness, accuracy, reliability or usefulness of
* the software.
*
* Permission to use this software is contingent upon your acceptance
* of the terms of this agreement
*
* .
*
*/
package io.github.lunasaw.gbproxy.server.transmit.request.register;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.Random;
import javax.sip.address.URI;
import javax.sip.header.AuthorizationHeader;
import javax.sip.message.Request;
import lombok.extern.slf4j.Slf4j;
/**
* Implements the HTTP digest authentication method server side functionality.
*
* @author M. Ranganathan
* @author Marc Bednarek
*/
@Slf4j
public class DigestServerAuthenticationHelper {
public static final MessageDigest messageDigest;
public static final String DEFAULT_ALGORITHM = "MD5";
public static final String DEFAULT_SCHEME = "Digest";
/**
* to hex converter
*/
private static final char[] toHex = {'0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* Default constructor.
*
* @throws NoSuchAlgorithmException
*/
static {
try {
messageDigest = MessageDigest.getInstance(DEFAULT_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}
public static String toHexString(byte b[]) {
int pos = 0;
char[] c = new char[b.length * 2];
for (int i = 0; i < b.length; i++) {
c[pos++] = toHex[(b[i] >> 4) & 0x0F];
c[pos++] = toHex[b[i] & 0x0f];
}
return new String(c);
}
/**
* Generate the challenge string.
*
* @return a generated nonce.
*/
public static String generateNonce() {
long time = Instant.now().toEpochMilli();
Random rand = new Random();
long pad = rand.nextLong();
String nonceString = Long.valueOf(time).toString()
+ Long.valueOf(pad).toString();
byte mdbytes[] = messageDigest.digest(nonceString.getBytes());
return toHexString(mdbytes);
}
/**
* Authenticate the inbound request.
*
* @param request - the request to authenticate.
* @param hashedPassword -- the MD5 hashed string of username:realm:plaintext password.
* @return true if authentication succeded and false otherwise.
*/
public static boolean doAuthenticateHashedPassword(Request request, String hashedPassword) {
AuthorizationHeader authHeader = (AuthorizationHeader) request.getHeader(AuthorizationHeader.NAME);
if (authHeader == null) {
return false;
}
String realm = authHeader.getRealm();
String username = authHeader.getUsername();
if (username == null || realm == null) {
return false;
}
String nonce = authHeader.getNonce();
URI uri = authHeader.getURI();
if (uri == null) {
return false;
}
String A2 = request.getMethod().toUpperCase() + ":" + uri.toString();
String HA1 = hashedPassword;
byte[] mdbytes = messageDigest.digest(A2.getBytes());
String HA2 = toHexString(mdbytes);
String cnonce = authHeader.getCNonce();
String KD = HA1 + ":" + nonce;
if (cnonce != null) {
KD += ":" + cnonce;
}
KD += ":" + HA2;
mdbytes = messageDigest.digest(KD.getBytes());
String mdString = toHexString(mdbytes);
String response = authHeader.getResponse();
return mdString.equals(response);
}
/**
* Authenticate the inbound request given plain text password.
*
* @param request - the request to authenticate.
* @param pass -- the plain text password.
* @return true if authentication succeded and false otherwise.
*/
public static boolean doAuthenticatePlainTextPassword(Request request, String pass) {
AuthorizationHeader authHeader = (AuthorizationHeader) request.getHeader(AuthorizationHeader.NAME);
if (authHeader == null || authHeader.getRealm() == null) {
return false;
}
String realm = authHeader.getRealm().trim();
String username = authHeader.getUsername().trim();
if (username == null || realm == null) {
return false;
}
String nonce = authHeader.getNonce();
URI uri = authHeader.getURI();
if (uri == null) {
return false;
}
// qop 保护质量 包含auth（默认的）和auth-int（增加了报文完整性检测）两种策略
String qop = authHeader.getQop();
// 客户端随机数，这是一个不透明的字符串值，由客户端提供，并且客户端和服务器都会使用，以避免用明文文本。
// 这使得双方都可以查验对方的身份，并对消息的完整性提供一些保护
String cnonce = authHeader.getCNonce();
// nonce计数器，是一个16进制的数值，表示同一nonce下客户端发送出请求的数量
int nc = authHeader.getNonceCount();
String ncStr = String.format("%08x", nc).toUpperCase();
// String ncStr = new DecimalFormat("00000000").format(nc);
// String ncStr = new DecimalFormat("00000000").format(Integer.parseInt(nc + "", 16));
String A1 = username + ":" + realm + ":" + pass;
String A2 = request.getMethod().toUpperCase() + ":" + uri.toString();
byte mdbytes[] = messageDigest.digest(A1.getBytes());
String HA1 = toHexString(mdbytes);
log.debug("A1: " + A1);
log.debug("A2: " + A2);
mdbytes = messageDigest.digest(A2.getBytes());
String HA2 = toHexString(mdbytes);
log.debug("HA1: " + HA1);
log.debug("HA2: " + HA2);
// String cnonce = authHeader.getCNonce();
log.debug("nonce: " + nonce);
log.debug("nc: " + ncStr);
log.debug("cnonce: " + cnonce);
log.debug("qop: " + qop);
String KD = HA1 + ":" + nonce;
if (qop != null && qop.equalsIgnoreCase("auth")) {
if (nc != -1) {
KD += ":" + ncStr;
}
if (cnonce != null) {
KD += ":" + cnonce;
}
KD += ":" + qop;
}
KD += ":" + HA2;
log.debug("KD: " + KD);
mdbytes = messageDigest.digest(KD.getBytes());
String mdString = toHexString(mdbytes);
log.debug("mdString: " + mdString);
String response = authHeader.getResponse();
log.debug("response: " + response);
return mdString.equals(response);
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/info/ServerInfoProcessorHandler.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/info/ServerInfoProcessorHandler.java | package io.github.lunasaw.gbproxy.server.transmit.request.info;
import javax.sip.RequestEvent;
/**
* Server模块INFO请求处理器业务接口
* 负责具体的INFO请求业务逻辑实现
*
* @author luna
*/
public interface ServerInfoProcessorHandler {
/**
* 处理INFO请求
*
* @param userId 用户ID
* @param content 请求内容
* @param evt 请求事件
*/
default void handleInfoRequest(String userId, String content, RequestEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
/**
* 验证设备权限
*
* @param userId 用户ID
* @param sipId SIP ID
* @param evt 请求事件
* @return 是否有权限
*/
default boolean validateDevicePermission(String userId, String sipId, RequestEvent evt) {
return true; // 默认验证通过
}
/**
* 处理INFO请求错误
*
* @param userId 用户ID
* @param errorMessage 错误消息
* @param evt 请求事件
*/
default void handleInfoError(String userId, String errorMessage, RequestEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/info/ServerInfoRequestProcessor.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/info/ServerInfoRequestProcessor.java | package io.github.lunasaw.gbproxy.server.transmit.request.info;
import org.springframework.beans.factory.annotation.Autowired;
import javax.sip.RequestEvent;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.gbproxy.server.transmit.request.ServerAbstractSipRequestProcessor;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* Server模块INFO请求处理器
* 只负责SIP协议层面的处理，业务逻辑通过ServerInfoProcessorHandler接口实现
*
* @author luna
*/
@Component("serverInfoRequestProcessor")
@Getter
@Setter
@Slf4j
public class ServerInfoRequestProcessor extends ServerAbstractSipRequestProcessor {
public static final String METHOD = "INFO";
private String method = METHOD;
@Autowired
@Lazy
private ServerInfoProcessorHandler serverInfoProcessorHandler;
/**
* 处理INFO请求
* 只负责SIP协议层面的处理，业务逻辑通过ServerInfoProcessorHandler接口实现
*
* @param evt 请求事件
*/
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest) evt.getRequest();
// 解析协议层面的信息
String sipId = SipUtils.getUserIdFromToHeader(request);
String userId = SipUtils.getUserIdFromFromHeader(request);
log.debug("处理INFO请求：用户ID = {}, SIP ID = {}", userId, sipId);
// 验证设备权限
if (!serverInfoProcessorHandler.validateDevicePermission(userId, sipId, evt)) {
log.warn("INFO请求权限验证失败：用户ID = {}, SIP ID = {}", userId, sipId);
serverInfoProcessorHandler.handleInfoError(userId, "权限验证失败", evt);
return;
}
// 获取请求内容
String content = "";
if (evt.getRequest().getRawContent() != null) {
content = new String(evt.getRequest().getRawContent());
}
// 调用业务处理器
serverInfoProcessorHandler.handleInfoRequest(userId, content, evt);
} catch (Exception e) {
log.error("处理INFO请求异常：evt = {}", evt, e);
String userId = SipUtils.getUserIdFromFromHeader((SIPRequest) evt.getRequest());
serverInfoProcessorHandler.handleInfoError(userId, e.getMessage(), evt);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/info/DefaultServerInfoProcessorHandler.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/transmit/request/info/DefaultServerInfoProcessorHandler.java | package io.github.lunasaw.gbproxy.server.transmit.request.info;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
/**
* Server模块INFO请求处理器业务接口默认实现
*
* @author luna
*/
@Slf4j
@Component
@ConditionalOnMissingBean(ServerInfoProcessorHandler.class)
public class DefaultServerInfoProcessorHandler implements ServerInfoProcessorHandler {
@Override
public void handleInfoRequest(String userId, String content, RequestEvent evt) {
log.debug("默认处理INFO请求：用户ID = {}, 内容 = {}", userId, content);
}
@Override
public boolean validateDevicePermission(String userId, String sipId, RequestEvent evt) {
log.debug("默认验证设备权限：用户ID = {}, SIP ID = {}", userId, sipId);
return true;
}
@Override
public void handleInfoError(String userId, String errorMessage, RequestEvent evt) {
log.debug("默认处理INFO请求错误：用户ID = {}, 错误消息 = {}", userId, errorMessage);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/entity/InviteEntity.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/entity/InviteEntity.java | package io.github.lunasaw.gbproxy.server.entity;
import io.github.lunasaw.gb28181.common.entity.enums.InviteSessionNameEnum;
import io.github.lunasaw.gb28181.common.entity.enums.ManufacturerEnum;
import io.github.lunasaw.gb28181.common.entity.enums.StreamModeEnum;
import io.github.lunasaw.sip.common.utils.SipUtils;
import org.apache.commons.lang3.StringUtils;
/**
* @author luna
* @date 2023/11/6
*/
public class InviteEntity {
public static void main(String[] args) {
StringBuffer inviteBody = getInvitePlayBody(StreamModeEnum.UDP, "41010500002000000001", "127.0.0.1", 5060, "1234567890");
System.out.println(inviteBody);
}
/**
* 组装subject
*
* @param subId 通道Id
* @param ssrc 混淆码
* @param userId 设备Id
* @return
*/
public static String getSubject(String subId, String ssrc, String userId) {
return String.format("%s:%s,%s:%s", subId, ssrc, userId, 0);
}
public static StringBuffer getInvitePlayBody(StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort, String ssrc) {
return getInvitePlayBody(false, streamModeEnum, userId, sdpIp, mediaPort, ssrc, false, null);
}
public static StringBuffer getInvitePlayBody(StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort, String ssrc,
Boolean subStream, ManufacturerEnum manufacturerEnum) {
return getInvitePlayBody(false, streamModeEnum, userId, sdpIp, mediaPort, ssrc, subStream, manufacturerEnum);
}
public static StringBuffer getInvitePlayBody(Boolean seniorSdp, StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort,
String ssrc) {
return getInvitePlayBody(seniorSdp, streamModeEnum, userId, sdpIp, mediaPort, ssrc, false, null);
}
public static StringBuffer getInvitePlayBody(Boolean seniorSdp, StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort,
String ssrc, Boolean subStream, ManufacturerEnum manufacturer) {
return getInvitePlayBody(InviteSessionNameEnum.PLAY, seniorSdp, streamModeEnum, userId, sdpIp, mediaPort, ssrc, subStream, manufacturer, null,
null);
}
public static StringBuffer getInvitePlayBackBody(StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort, String ssrc,
String startTime, String endTime) {
return getInvitePlayBodyBack(false, streamModeEnum, userId, sdpIp, mediaPort, ssrc, false, null, startTime, endTime);
}
public static StringBuffer getInvitePlayBodyBack(Boolean seniorSdp, StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort,
String ssrc, Boolean subStream, ManufacturerEnum manufacturer, String startTime, String endTime) {
return getInvitePlayBody(InviteSessionNameEnum.PLAY_BACK, seniorSdp, streamModeEnum, userId, sdpIp, mediaPort, ssrc, subStream, manufacturer,
startTime, endTime);
}
/**
*
* @param seniorSdp [可选] 部分设备需要扩展SDP，需要打开此设置
* @param streamModeEnum [必填] 流传输模式
* @param userId [必填] 设备Id
* @param sdpIp [必填] 设备IP
* @param mediaPort [必填] 设备端口
* @param ssrc [必填] 混淆码
* @param subStream [可选] 是否子码流
* @param manufacturer [可选] 设备厂商
* @return
*/
public static StringBuffer getInvitePlayBody(InviteSessionNameEnum inviteSessionNameEnum, Boolean seniorSdp, StreamModeEnum streamModeEnum,
String userId, String sdpIp, Integer mediaPort,
String ssrc, Boolean subStream, ManufacturerEnum manufacturer, String startTime, String endTime) {
StringBuffer content = new StringBuffer(200);
content.append("v=0\r\n");
content.append("o=").append(userId).append(" 0 0 IN IP4 ").append(sdpIp).append("\r\n");
// Session Name
content.append("s=").append(inviteSessionNameEnum.getType()).append("\r\n");
content.append("u=").append(userId).append(":0\r\n");
content.append("c=IN IP4 ").append(sdpIp).append("\r\n");
if (InviteSessionNameEnum.PLAY_BACK.equals(inviteSessionNameEnum)) {
// 将 ISO 8601 时间格式转换为 NTP 时间戳
long startTimeNtp = SipUtils.toNtpTimestamp(startTime);
long endTimeNtp = SipUtils.toNtpTimestamp(endTime);
content.append("t=").append(startTimeNtp).append(" ").append(endTimeNtp).append("\r\n");
} else {
content.append("t=0 0\r\n");
}
if (seniorSdp) {
if (StreamModeEnum.TCP_PASSIVE.equals(streamModeEnum)) {
content.append("m=video ").append(mediaPort).append(" TCP/RTP/AVP 96 126 125 99 34 98 97\r\n");
} else if (StreamModeEnum.TCP_ACTIVE.equals(streamModeEnum)) {
content.append("m=video ").append(mediaPort).append(" TCP/RTP/AVP 96 126 125 99 34 98 97\r\n");
} else if (StreamModeEnum.UDP.equals(streamModeEnum)) {
content.append("m=video ").append(mediaPort).append(" RTP/AVP 96 126 125 99 34 98 97\r\n");
}
content.append("a=recvonly\r\n");
content.append("a=rtpmap:96 PS/90000\r\n");
content.append("a=fmtp:126 profile-level-id=42e01e\r\n");
content.append("a=rtpmap:126 H264/90000\r\n");
content.append("a=rtpmap:125 H264S/90000\r\n");
content.append("a=fmtp:125 profile-level-id=42e01e\r\n");
content.append("a=rtpmap:99 H265/90000\r\n");
content.append("a=rtpmap:98 H264/90000\r\n");
content.append("a=rtpmap:97 MPEG4/90000\r\n");
if (StreamModeEnum.TCP_PASSIVE.equals(streamModeEnum)) {
content.append("a=setup:passive\r\n");
content.append("a=connection:new\r\n");
} else if (StreamModeEnum.TCP_ACTIVE.equals(streamModeEnum)) {
content.append("a=setup:active\r\n");
content.append("a=connection:new\r\n");
}
} else {
if (StreamModeEnum.TCP_PASSIVE.equals(streamModeEnum)) {
content.append("m=video ").append(mediaPort).append(" TCP/RTP/AVP 96 97 98 99\r\n");
} else if (StreamModeEnum.TCP_ACTIVE.equals(streamModeEnum)) {
content.append("m=video ").append(mediaPort).append(" TCP/RTP/AVP 96 97 98 99\r\n");
} else if (StreamModeEnum.UDP.equals(streamModeEnum)) {
content.append("m=video ").append(mediaPort).append(" RTP/AVP 96 97 98 99\r\n");
}
content.append("a=recvonly\r\n");
content.append("a=rtpmap:96 PS/90000\r\n");
content.append("a=rtpmap:97 MPEG4/90000\r\n");
content.append("a=rtpmap:98 H264/90000\r\n");
content.append("a=rtpmap:99 H265/90000\r\n");
if (StreamModeEnum.TCP_PASSIVE.equals(streamModeEnum)) {
content.append("a=setup:passive\r\n");
content.append("a=connection:new\r\n");
} else if (StreamModeEnum.TCP_ACTIVE.equals(streamModeEnum)) {
content.append("a=setup:active\r\n");
content.append("a=connection:new\r\n");
}
}
addSsrc(content, ssrc);
if (InviteSessionNameEnum.PLAY.equals(inviteSessionNameEnum)) {
addSubStream(content, subStream, manufacturer);
}
return content;
}
public static StringBuffer addSsrc(StringBuffer content, String ssrc) {
content.append("y=").append(ssrc).append("\r\n");// ssrc
return content;
}
public static StringBuffer addSubStream(StringBuffer content, Boolean subStream, ManufacturerEnum manufacturer) {
if (ManufacturerEnum.TP_LINK.equals(manufacturer)) {
if (subStream) {
content.append("a=streamMode:sub\r\n");
} else {
content.append("a=streamMode:main\r\n");
}
} else {
if (subStream) {
content.append("a=streamprofile:1\r\n");
} else {
content.append("a=streamprofile:0\r\n");
}
}
return content;
}
// ======================== 以下是回放控制 ========================
public static String playPause() {
return playPause(null);
}
/**
* 回放暂停
*
* @param cseq
*/
public static String playPause(String cseq) {
if (StringUtils.isBlank(cseq)) {
cseq = String.valueOf(getInfoCseq());
}
StringBuilder content = new StringBuilder(200);
content.append("PAUSE RTSP/1.0\r\n");
content.append("CSeq: ").append(cseq).append("\r\n");
content.append("PauseTime: now\r\n");
return content.toString();
}
public static String playNow() {
return playNow(null);
}
/**
* 回放恢复
*
* @param cseq
* @return
*/
public static String playNow(String cseq) {
if (StringUtils.isBlank(cseq)) {
cseq = String.valueOf(getInfoCseq());
}
StringBuffer content = new StringBuffer(200);
content.append("PLAY RTSP/1.0\r\n");
content.append("CSeq: ").append(cseq).append("\r\n");
content.append("Range: npt=now-\r\n");
return content.toString();
}
public static String playRange(long seekTime) {
return playRange(null, seekTime);
}
/**
* 回放定位
*
* @param cseq
* @param seekTime
* @return
*/
public static String playRange(String cseq, long seekTime) {
if (StringUtils.isBlank(cseq)) {
cseq = String.valueOf(getInfoCseq());
}
StringBuffer content = new StringBuffer(200);
content.append("PLAY RTSP/1.0\r\n");
content.append("CSeq: ").append(cseq).append("\r\n");
content.append("Range: npt=").append(Math.abs(seekTime)).append("-\r\n");
return content.toString();
}
public static String playSpeed(Double speed) {
return playSpeed(null, speed);
}
/**
* 回放倍速
*
* @param cseq
* @param speed
* @return
*/
public static String playSpeed(String cseq, Double speed) {
if (StringUtils.isBlank(cseq)) {
cseq = String.valueOf(getInfoCseq());
}
StringBuffer content = new StringBuffer(200);
content.append("PLAY RTSP/1.0\r\n");
content.append("CSeq: ").append(cseq).append("\r\n");
content.append("Scale: ").append(String.format("%.6f", speed)).append("\r\n");
return content.toString();
}
private static int getInfoCseq() {
return (int) ((Math.random() * 9 + 1) * Math.pow(10, 8));
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/entity/InviteRequest.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/entity/InviteRequest.java | package io.github.lunasaw.gbproxy.server.entity;
import io.github.lunasaw.gb28181.common.entity.enums.ManufacturerEnum;
import io.github.lunasaw.gb28181.common.entity.enums.StreamModeEnum;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Data;
/**
* @author luna
* @date 2023/11/16
*/
@Data
public class InviteRequest {
/**
* 是否高级sdp
*/
private Boolean seniorSdp;
/**
* 流媒体传输模式
*/
private StreamModeEnum streamModeEnum;
/**
* 用户ID
*/
private String userId;
/**
* 收流IP
*/
private String sdpIp;
/**
* 收流端口
*/
private Integer mediaPort;
/**
* ssrc
*/
private String ssrc;
/**
* 是否订阅子码流
*/
private Boolean subStream;
/**
* 厂商
*/
private ManufacturerEnum manufacturer;
/**
* 回放开始时间
*/
private String startTime;
/**
* 回放结束时间
*/
private String endTime;
public InviteRequest(String userId, StreamModeEnum streamModeEnum, String sdpIp, Integer mediaPort) {
this.seniorSdp = false;
this.streamModeEnum = streamModeEnum;
this.userId = userId;
this.sdpIp = sdpIp;
this.mediaPort = mediaPort;
this.ssrc = SipUtils.genSsrc(userId);
}
public InviteRequest(Boolean seniorSdp, StreamModeEnum streamModeEnum, String userId, String sdpIp, Integer mediaPort, String ssrc) {
this.seniorSdp = seniorSdp;
this.streamModeEnum = streamModeEnum;
this.userId = userId;
this.sdpIp = sdpIp;
this.mediaPort = mediaPort;
this.ssrc = ssrc;
}
public InviteRequest(String userId, StreamModeEnum streamModeEnum, String sdpIp, Integer mediaPort, String startTime, String endTime) {
this.seniorSdp = false;
this.streamModeEnum = streamModeEnum;
this.userId = userId;
this.sdpIp = sdpIp;
this.mediaPort = mediaPort;
this.ssrc = SipUtils.genSsrc(userId);
this.startTime = startTime;
this.endTime = endTime;
}
public String getContent() {
if (seniorSdp == null || !seniorSdp) {
return InviteEntity.getInvitePlayBody(streamModeEnum, userId, sdpIp, mediaPort, ssrc).toString();
}
return getContentWithSdp();
}
public String getBackContent() {
return InviteEntity.getInvitePlayBackBody(streamModeEnum, userId, sdpIp, mediaPort, ssrc, startTime, endTime).toString();
}
public String getContentWithSub() {
return InviteEntity.getInvitePlayBody(streamModeEnum, userId, sdpIp, mediaPort, ssrc, subStream, manufacturer).toString();
}
public String getContentWithSdp() {
return InviteEntity.getInvitePlayBody(seniorSdp, streamModeEnum, userId, sdpIp, mediaPort, ssrc).toString();
}
public String getSubject(String currentUserId) {
return InviteEntity.getSubject(userId, ssrc, currentUserId);
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/config/SipProxyServerAutoConfig.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/config/SipProxyServerAutoConfig.java | package io.github.lunasaw.gbproxy.server.config;
import io.github.lunasaw.gbproxy.server.transmit.request.message.MessageServerHandlerAbstract;
import io.github.lunasaw.gbproxy.server.transmit.request.message.ServerMessageRequestProcessor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author luna
* @date 2023/10/16
*/
@Slf4j
@Component
@ComponentScan(basePackages = "io.github.lunasaw.gbproxy.server")
public class SipProxyServerAutoConfig implements InitializingBean, ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void afterPropertiesSet() {
Map<String, MessageServerHandlerAbstract> messageHandlerMap = applicationContext.getBeansOfType(MessageServerHandlerAbstract.class);
messageHandlerMap.forEach((k, v) -> ServerMessageRequestProcessor.addHandler(v));
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/config/SipServerProperties.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/config/SipServerProperties.java | package io.github.lunasaw.gbproxy.server.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* Voglander SIP服务端配置属性
*
* @author luna
* @since 2025/8/2
*/
@Data
@Component
@ConfigurationProperties(prefix = "sip.server")
public class SipServerProperties {
/**
* 是否启用服务端
*/
private boolean enabled = false;
/**
* 服务器IP
*/
private String ip = "127.0.0.1";
/**
* 服务器端口
*/
private int port = 5060;
/**
* 最大设备数
*/
private int maxDevices = 100;
/**
* 设备超时时间
*/
private String deviceTimeout = "5m";
/**
* 是否启用TCP
*/
private boolean enableTcp = false;
/**
* 是否启用UDP
*/
private boolean enableUdp = true;
/**
* 域
*/
private String domain = "34020000002000000001";
/**
* 服务器ID
*/
private String serverId = "34020000002000000001";
/**
* 服务器名称
*/
private String serverName = "GB28181-Server";
/**
* 用户名
*/
private String username = "admin";
/**
* 密码
*/
private String password;
/**
* 域
*/
private String realm = "34020000";
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/enums/PlayActionEnums.java | gb28181-server/src/main/java/io/github/lunasaw/gbproxy/server/enums/PlayActionEnums.java | package io.github.lunasaw.gbproxy.server.enums;
import io.github.lunasaw.gbproxy.server.entity.InviteEntity;
import lombok.Getter;
import org.springframework.util.Assert;
/**
* 国标点播操作类型
*
* @author luna
*/
@Getter
public enum PlayActionEnums {
PLAY_RESUME("playResume", "回放暂停", null),
PLAY_RANGE("playRange", "回放Seek", ""),
PLAY_SPEED("playSpeed", "倍速回放", 1.0),
PLAY_NOW("playNow", "继续回放", null);
private final String type;
private final String desc;
private final Object data;
PlayActionEnums(String type, String desc, Object data) {
this.type = type;
this.desc = desc;
this.data = data;
}
public String getControlBody() {
return getControlBody(data);
}
public String getControlBody(Object data) {
if (PLAY_RESUME.equals(this)) {
return InviteEntity.playPause();
} else if (PLAY_RANGE.equals(this)) {
Assert.notNull(data, "回放Seek时间不能为空");
return InviteEntity.playRange((Long) data);
} else if (PLAY_SPEED.equals(this)) {
Assert.notNull(data, "倍速回放倍数不能为空");
return InviteEntity.playSpeed((Double) data);
} else if (PLAY_NOW.equals(this)) {
return InviteEntity.playNow();
}
return null;
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/TransactionTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/TransactionTest.java | package io.github.lunasaw.gbproxy.test;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.sip.RequestEvent;
import javax.sip.ServerTransaction;
import io.github.lunasaw.sip.common.transmit.event.request.SipRequestProcessor;
/**
* 测试事务预创建功能
*
* @author luna
*/
public class TransactionTest {
private static final Logger log = LoggerFactory.getLogger(TransactionTest.class);
@Test
public void testSipRequestProcessorInterface() {
// 测试SipRequestProcessor接口的新方法
SipRequestProcessor processor = new SipRequestProcessor() {
@Override
public void process(RequestEvent event) {
log.info("处理请求事件（原方法）: {}", event);
}
@Override
public void process(RequestEvent event, ServerTransaction serverTransaction) {
log.info("处理请求事件（带事务）: event={}, transaction={}", event, serverTransaction);
}
};
// 模拟调用
RequestEvent mockEvent = null; // 实际测试中需要真实的RequestEvent
ServerTransaction mockTransaction = null; // 实际测试中需要真实的ServerTransaction
// 测试默认实现
processor.process(mockEvent);
processor.process(mockEvent, mockTransaction);
log.info("SipRequestProcessor接口测试通过");
}
@Test
public void testTransactionCreationLogic() {
// 测试AbstractSipListener中的shouldCreateTransaction逻辑
// 模拟MESSAGE请求 - 应该创建事务
boolean shouldCreateForMessage = shouldCreateTransaction("MESSAGE");
assert shouldCreateForMessage : "MESSAGE方法应该创建事务";
// 模拟ACK请求 - 不应该创建事务
boolean shouldCreateForAck = shouldCreateTransaction("ACK");
assert !shouldCreateForAck : "ACK方法不应该创建事务";
// 模拟INVITE请求 - 应该创建事务
boolean shouldCreateForInvite = shouldCreateTransaction("INVITE");
assert shouldCreateForInvite : "INVITE方法应该创建事务";
log.info("事务创建逻辑测试通过");
}
/**
* 模拟AbstractSipListener.shouldCreateTransaction方法的逻辑
*/
private boolean shouldCreateTransaction(String method) {
// MESSAGE、INFO、NOTIFY等需要响应的方法需要事务支持
// ACK方法通常不需要服务器事务
return !"ACK".equals(method);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/Gb28181RegistrationTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/Gb28181RegistrationTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.gbproxy.test.config.TestDeviceSupplier;
import io.github.lunasaw.gbproxy.test.handler.TestServerRegisterProcessorHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.layer.SipLayer;
import io.github.lunasaw.sip.common.transmit.request.SipRequestBuilderFactory;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.utils.SipUtils;
import io.github.lunasaw.sip.common.utils.SipRequestUtils;
import gov.nist.javax.sip.message.SIPRequest;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import javax.sip.SipListener;
import javax.sip.header.AuthorizationHeader;
import javax.sip.header.WWWAuthenticateHeader;
import javax.sip.message.Request;
import javax.sip.message.Response;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/**
* GB28181注册协议测试类
* 基于GB28181-2016标准9.1.2节实现基本注册和双向认证注册测试
* <p>
* 测试包括：
* 1. 基本注册流程（9.1.2.1）- 基于数字摘要的挑战应答式安全技术
* 2. 基于数字证书的双向认证注册（9.1.2.2）
*
* @author claude
* @date 2025/07/21
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class,
webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class Gb28181RegistrationTest extends BasicSipCommonTest {
private final AtomicReference<Response> lastResponse = new AtomicReference<>();
private final AtomicBoolean responseReceived = new AtomicBoolean(false);
private final CountDownLatch responseLatch = new CountDownLatch(1);
@BeforeEach
@Override
public void setUp() {
super.setUp();
// 额外的SIP监听点设置，确保监听点存在
if (sipLayer != null) {
try {
// 确保监听点存在
sipLayer.addListeningPoint("127.0.0.1", 5060);
sipLayer.addListeningPoint("127.0.0.1", 5061);
System.out.println("🔧 额外确保SIP监听点设置完成: 5060, 5061");
} catch (Exception e) {
System.out.println("⚠️ SIP监听点设置异常: " + e.getMessage());
}
}
// 重置测试状态
TestServerRegisterProcessorHandler.resetTestState();
lastResponse.set(null);
responseReceived.set(false);
System.out.println("🔄 重置注册测试状态");
}
@Test
@Order(1)
@DisplayName("9.1.2.1 基本注册流程测试")
public void testBasicRegistrationFlow() throws Exception {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过基本注册测试 - 设备提供器未注入");
return;
}
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过基本注册测试 - 设备未获取");
return;
}
System.out.println("📋 开始基本注册流程测试 (GB28181-2016 9.1.2.1)");
System.out.println(" 客户端设备: " + clientFromDevice.getUserId() + "@" +
clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
System.out.println(" 服务端设备: " + clientToDevice.getUserId() + "@" +
clientToDevice.getIp() + ":" + clientToDevice.getPort());
// 步骤1: 发送初始REGISTER请求（无认证信息）
System.out.println("\n📤 步骤1: 发送初始REGISTER请求");
String callId = "register-test-" + System.currentTimeMillis();
Request registerRequest = SipRequestBuilderFactory.createRegisterRequest(
clientFromDevice, clientToDevice, 3600, callId);
SipSender.doRegisterRequest(clientFromDevice, clientToDevice, 3600);
Assertions.assertNotNull(registerRequest, "REGISTER请求应该被成功创建");
Assertions.assertEquals("REGISTER", registerRequest.getMethod(), "请求方法应该是REGISTER");
System.out.println("✅ REGISTER请求发送成功，CallId: " + callId);
// 步骤2: 等待服务端注册事件
System.out.println("\n📥 步骤2: 等待服务端处理注册请求");
boolean registerReceived = TestServerRegisterProcessorHandler.waitForRegister(5, java.util.concurrent.TimeUnit.SECONDS);
Assertions.assertTrue(registerReceived, "服务端应该在5秒内接收到注册请求");
Assertions.assertTrue(TestServerRegisterProcessorHandler.hasReceivedRegister(),
"服务端应该成功接收注册信息");
String registeredUserId = TestServerRegisterProcessorHandler.getRegisteredUserId();
Assertions.assertNotNull(registeredUserId, "注册的用户ID不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), registeredUserId,
"注册的用户ID应该与发送方设备ID一致");
// 步骤3: 验证设备上线事件
System.out.println("\n🟢 步骤3: 验证设备上线事件");
boolean deviceOnlineReceived = TestServerRegisterProcessorHandler.waitForDeviceOnline(5, java.util.concurrent.TimeUnit.SECONDS);
Assertions.assertTrue(deviceOnlineReceived, "服务端应该接收到设备上线事件");
Assertions.assertTrue(TestServerRegisterProcessorHandler.hasReceivedDeviceOnline(),
"服务端应该成功处理设备上线");
String onlineUserId = TestServerRegisterProcessorHandler.getOnlineUserId();
Assertions.assertEquals(clientFromDevice.getUserId(), onlineUserId,
"上线设备ID应该与注册设备ID一致");
System.out.println("✅ 注册信息验证通过: 用户ID=" + registeredUserId);
System.out.println("✅ 设备上线验证通过: 用户ID=" + onlineUserId);
System.out.println("✅ CallId验证通过: " + callId);
System.out.println("🎉 基本注册流程测试完全成功！");
}
@Test
@Order(2)
@DisplayName("9.1.2.2 基于数字证书的双向认证注册测试")
public void testCertificateBasedDualAuthenticationRegistration() throws Exception {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过双向认证注册测试 - 设备提供器未注入");
return;
}
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过双向认证注册测试 - 设备未获取");
return;
}
System.out.println("📋 开始基于数字证书的双向认证注册测试 (GB28181-2016 9.1.2.2)");
// 测试注册请求的核心功能
System.out.println("\n📤 发送双向认证注册请求");
String callId = "dual-auth-test-" + System.currentTimeMillis();
Request registerRequest = SipRequestBuilderFactory.createRegisterRequest(
clientFromDevice, clientToDevice, 3600, callId);
// 使用SipSender直接发送请求
SipSender.doRegisterRequest(clientFromDevice, clientToDevice, 3600);
Assertions.assertNotNull(registerRequest, "双向认证REGISTER请求应该被成功创建");
Assertions.assertEquals("REGISTER", registerRequest.getMethod(), "请求方法应该是REGISTER");
System.out.println("✅ 双向认证REGISTER请求发送成功，CallId: " + callId);
// 验证服务器处理
System.out.println("\n📥 等待服务器处理双向认证注册请求");
boolean registerReceived = TestServerRegisterProcessorHandler.waitForRegister(5, TimeUnit.SECONDS);
Assertions.assertTrue(registerReceived, "服务端应该在5秒内接收到双向认证注册请求");
Assertions.assertTrue(TestServerRegisterProcessorHandler.hasReceivedRegister(),
"服务端应该成功接收双向认证注册信息");
String registeredUserId = TestServerRegisterProcessorHandler.getRegisteredUserId();
Assertions.assertEquals(clientFromDevice.getUserId(), registeredUserId,
"双向认证注册的用户ID应该与发送方设备ID一致");
// 验证设备上线
boolean deviceOnlineReceived = TestServerRegisterProcessorHandler.waitForDeviceOnline(5, TimeUnit.SECONDS);
Assertions.assertTrue(deviceOnlineReceived, "服务端应该接收到设备上线事件");
System.out.println("✅ 双向认证注册验证通过: 用户ID=" + registeredUserId);
System.out.println("✅ CallId验证通过: " + callId);
System.out.println("🎉 基于数字证书的双向认证注册测试完成！");
// 这里的测试重点是验证注册流程的完整性，实际的数字证书认证逻辑
// 需要在具体的认证实现中进行更详细的测试
System.out.println("📝 注意: 本测试验证了双向认证注册的基本流程");
System.out.println("📝 实际的数字证书验证逻辑需要在认证模块中进行专门测试");
}
@Test
@Order(3)
@DisplayName("测试设备注销流程")
public void testDeviceUnregistrationFlow() throws Exception {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过设备注销测试 - 设备提供器未注入");
return;
}
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过设备注销测试 - 设备未获取");
return;
}
System.out.println("📋 开始设备注销流程测试");
System.out.println(" 客户端设备: " + clientFromDevice.getUserId() + "@" +
clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
// 发送注销命令（expires=0）
System.out.println("\n📤 发送设备注销请求");
String callId = "unregister-test-" + System.currentTimeMillis();
Request unregisterRequest = SipRequestBuilderFactory.createRegisterRequest(
clientFromDevice, clientToDevice, 0, callId);
// 使用SipSender直接发送请求
SipSender.doRegisterRequest(clientFromDevice, clientToDevice, 0);
Assertions.assertNotNull(unregisterRequest, "注销请求应该被成功创建");
Assertions.assertEquals("REGISTER", unregisterRequest.getMethod(), "请求方法应该是REGISTER");
System.out.println("✅ 注销请求发送成功，CallId: " + callId);
// 等待服务器处理设备下线
System.out.println("\n📥 等待服务器处理设备下线");
boolean deviceOfflineReceived = TestServerRegisterProcessorHandler.waitForDeviceOffline(5, TimeUnit.SECONDS);
Assertions.assertTrue(deviceOfflineReceived, "服务端应该在5秒内接收到设备下线事件");
Assertions.assertTrue(TestServerRegisterProcessorHandler.hasReceivedDeviceOffline(),
"服务端应该成功处理设备下线");
String offlineUserId = TestServerRegisterProcessorHandler.getOfflineUserId();
Assertions.assertNotNull(offlineUserId, "下线的用户ID不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), offlineUserId,
"下线设备ID应该与发送方设备ID一致");
System.out.println("✅ 设备下线验证通过: 用户ID=" + offlineUserId);
System.out.println("✅ CallId验证通过: " + callId);
System.out.println("🎉 设备注销流程测试完全成功！");
}
@Test
@Order(4)
@DisplayName("验证REGISTER请求结构完整性")
public void testRegisterRequestStructure() throws Exception {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过请求结构测试 - 设备提供器未注入");
return;
}
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过请求结构测试 - 设备未获取");
return;
}
System.out.println("📋 开始REGISTER请求结构验证测试");
// 创建并验证REGISTER请求结构
String callId = "structure-test-" + System.currentTimeMillis();
Request registerRequest = SipRequestBuilderFactory.createRegisterRequest(
clientFromDevice, clientToDevice, 3600, callId);
System.out.println("📤 验证REGISTER请求结构");
verifyRegisterRequestStructure(registerRequest, false);
// 创建并验证带认证的REGISTER请求结构
Request authenticatedRequest = createAuthenticatedRegisterRequest(
clientFromDevice, clientToDevice, callId);
System.out.println("📤 验证带认证的REGISTER请求结构");
verifyRegisterRequestStructure(authenticatedRequest, true);
System.out.println("✅ 所有REGISTER请求结构验证通过");
System.out.println("🎉 REGISTER请求结构完整性测试完成！");
}
/**
* 创建带认证信息的REGISTER请求
*/
private Request createAuthenticatedRegisterRequest(FromDevice fromDevice, ToDevice toDevice, String callId)
throws Exception {
Request registerRequest = SipRequestBuilderFactory.createRegisterRequest(fromDevice, toDevice, 3600, callId);
// 添加Authorization头（模拟认证信息）
SIPRequest sipRequest = (SIPRequest) registerRequest;
AuthorizationHeader authHeader = SipRequestUtils.createAuthorizationHeader("Digest");
sipRequest.addHeader(authHeader);
return registerRequest;
}
/**
* 验证REGISTER请求结构
*/
private void verifyRegisterRequestStructure(Request request, boolean shouldHaveAuth) {
Assertions.assertNotNull(request, "请求不能为空");
Assertions.assertEquals("REGISTER", request.getMethod(), "请求方法必须是REGISTER");
// 验证必要的SIP头
Assertions.assertNotNull(request.getHeader("From"), "From头不能为空");
Assertions.assertNotNull(request.getHeader("To"), "To头不能为空");
Assertions.assertNotNull(request.getHeader("Call-ID"), "Call-ID头不能为空");
Assertions.assertNotNull(request.getHeader("CSeq"), "CSeq头不能为空");
Assertions.assertNotNull(request.getHeader("Via"), "Via头不能为空");
Assertions.assertNotNull(request.getHeader("Contact"), "Contact头不能为空");
Assertions.assertNotNull(request.getHeader("Expires"), "Expires头不能为空");
// 验证认证头
AuthorizationHeader authHeader = (AuthorizationHeader) request.getHeader("Authorization");
if (shouldHaveAuth) {
Assertions.assertNotNull(authHeader, "认证请求必须包含Authorization头");
} else {
Assertions.assertNull(authHeader, "初始请求不应该包含Authorization头");
}
System.out.println("✅ REGISTER请求结构验证通过");
}
@AfterEach
@Override
public void tearDown() {
super.tearDown();
System.out.println("🧹 清理注册测试状态");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/MinimalTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/MinimalTest.java | package io.github.lunasaw.gbproxy.test;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
/**
* 最小化测试类
* 用于验证Spring上下文是否能正常加载
*
* @author luna
* @date 2025/01/23
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class,
webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.root=WARN",
"logging.level.io.github.lunasaw=INFO"
})
public class MinimalTest {
@Test
public void testContextLoads() {
// 这个测试只验证Spring上下文是否能正常加载
System.out.println("Spring上下文加载成功");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/RecordSearchTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/RecordSearchTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gb28181.common.entity.query.RecordInfoQuery;
import io.github.lunasaw.gb28181.common.entity.response.RecordInfoResponse;
import io.github.lunasaw.gbproxy.server.transmit.cmd.ServerCommandSender;
import io.github.lunasaw.gbproxy.test.handler.TestClientMessageProcessorHandler;
import io.github.lunasaw.gbproxy.test.handler.TestServerMessageProcessorHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.utils.XmlUtils;
import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.ConcurrentHashMap;
/**
* GB28181 设备视音频文件检索测试类 - 完整流程测试
* 根据 GB28181-2016 标准 9.7 节实现
*
* 正确的测试流程：
* 1. 服务端发起RecordInfo查询请求 → 客户端
* 2. 客户端分多条MESSAGE响应 → 服务端（同一个CallId）
* 3. 服务端使用本地Map缓存按CallId聚合所有响应记录
* 4. 验证完整的录像检索和存储流程
*
* @author claude
* @date 2025/07/27
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class,
webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class RecordSearchTest extends BasicSipCommonTest {
private static final String RECORD_INFO_CMD_TYPE = "RecordInfo";
private static final String CACHE_KEY_PREFIX = "gb28181:record:";
// 使用本地Map模拟Redis缓存功能
private static final Map<String, Object> mockCache = new ConcurrentHashMap<>();
private final AtomicInteger totalExpectedRecords = new AtomicInteger(0);
private final CountDownLatch responseLatch = new CountDownLatch(1);
private String testCallId;
@BeforeEach
@Override
public void setUp() {
super.setUp();
// 重置测试状态
TestServerMessageProcessorHandler.resetTestState();
TestClientMessageProcessorHandler.resetTestState();
testCallId = "record-search-test-" + System.currentTimeMillis();
// 清理模拟缓存
clearMockCache();
System.out.println("🔄 重置录像检索测试状态，CallId: " + testCallId);
}
@Test
@Order(1)
@DisplayName("9.7 完整录像检索流程测试：服务端查询 → 客户端多条响应 → 本地缓存聚合")
public void testCompleteRecordSearchFlow() throws Exception {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过完整流程测试 - 设备提供器未注入");
return;
}
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (serverFromDevice == null || serverToDevice == null ||
clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过完整流程测试 - 设备未获取");
return;
}
System.out.println("📋 开始完整录像检索流程测试 (GB28181-2016 9.7)");
System.out.println(" 服务端设备: " + serverFromDevice.getUserId() + "@" +
serverFromDevice.getIp() + ":" + serverFromDevice.getPort());
System.out.println(" 客户端设备: " + clientFromDevice.getUserId() + "@" +
clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
System.out.println(" 测试CallId: " + testCallId);
// 步骤1: 服务端发起录像检索查询
System.out.println("\n📤 步骤1: 服务端发起录像检索查询");
RecordInfoQuery query = createRecordInfoQuery(clientFromDevice.getUserId());
String queryXml = XmlUtils.toString("UTF-8", query);
// 服务端发送查询请求到客户端（使用现有的方法）
String queryCallId = ServerCommandSender.deviceRecordInfoQuery(
serverFromDevice, clientToDevice,
query.getStartTime(), query.getEndTime());
Assertions.assertNotNull(queryCallId, "录像检索查询请求应该发送成功");
System.out.println("✅ 服务端查询请求发送成功，CallId: " + queryCallId);
// 步骤2: 模拟客户端多条响应（模拟大量录像记录）
System.out.println("\n📤 步骤2: 模拟客户端发送多条录像响应");
int totalRecords = 250; // 总共250条记录
int recordsPerMessage = 50; // 每条消息50条记录
int expectedMessages = (int) Math.ceil((double) totalRecords / recordsPerMessage);
totalExpectedRecords.set(totalRecords);
System.out.println(" 总记录数: " + totalRecords);
System.out.println(" 每条消息记录数: " + recordsPerMessage);
System.out.println(" 预期消息数: " + expectedMessages);
// 模拟客户端分批发送响应并存储到缓存
List<RecordInfoResponse> allResponses = new ArrayList<>();
for (int i = 0; i < expectedMessages; i++) {
int startIndex = i * recordsPerMessage;
int endIndex = Math.min(startIndex + recordsPerMessage, totalRecords);
int currentRecords = endIndex - startIndex;
RecordInfoResponse response = createRecordInfoResponse(
clientFromDevice.getUserId(),
totalRecords,
currentRecords,
startIndex + 1,
queryCallId); // 使用相同的CallId
// 存储到本地缓存（模拟服务端接收并存储）
String cacheKey = CACHE_KEY_PREFIX + queryCallId + ":part:" + i;
mockCache.put(cacheKey, response);
allResponses.add(response);
System.out.println("📤 第" + (i + 1) + "条响应模拟，记录范围: " +
(startIndex + 1) + "-" + endIndex + "，缓存Key: " + cacheKey);
}
// 步骤3: 验证本地缓存中的聚合结果
System.out.println("\n🔍 步骤3: 验证本地缓存聚合结果");
verifyMockCacheAggregation(queryCallId, totalRecords, expectedMessages);
// 步骤4: 验证最终聚合结果
System.out.println("\n🔍 步骤4: 验证最终聚合结果");
Assertions.assertEquals(expectedMessages, allResponses.size(),
"聚合响应数量应该等于预期消息数");
// 验证总记录数
int totalAggregatedRecords = allResponses.stream()
.mapToInt(resp -> resp.getRecordList() != null ? resp.getRecordList().getNum() : 0)
.sum();
Assertions.assertEquals(totalRecords, totalAggregatedRecords,
"聚合的总记录数应该等于预期数量");
System.out.println("✅ 服务端成功聚合所有响应");
System.out.println("✅ 总消息数验证通过: " + expectedMessages);
System.out.println("✅ 总记录数验证通过: " + totalAggregatedRecords);
System.out.println("🎉 完整录像检索流程测试成功！");
System.out.println("📝 验证了GB28181协议核心要求：多条MESSAGE分片传输和CallId聚合");
}
@Test
@Order(2)
@DisplayName("本地缓存机制测试：按CallId聚合多条响应")
public void testLocalCacheAggregation() throws Exception {
System.out.println("📋 开始本地缓存聚合机制测试");
String cacheTestCallId = "cache-test-" + System.currentTimeMillis();
int testRecords = 100;
int messagesCount = 4;
int recordsPerMessage = 25;
// 模拟多条响应写入本地缓存
for (int i = 0; i < messagesCount; i++) {
RecordInfoResponse response = createRecordInfoResponse(
"test-device-001",
testRecords,
recordsPerMessage,
i * recordsPerMessage + 1,
cacheTestCallId);
// 写入本地缓存
String cacheKey = CACHE_KEY_PREFIX + cacheTestCallId + ":part:" + i;
mockCache.put(cacheKey, response);
System.out.println("📝 写入本地缓存: " + cacheKey + "，记录数: " + recordsPerMessage);
}
// 验证本地缓存中的数据
System.out.println("\n🔍 验证本地缓存数据");
for (int i = 0; i < messagesCount; i++) {
String cacheKey = CACHE_KEY_PREFIX + cacheTestCallId + ":part:" + i;
RecordInfoResponse cachedResponse = (RecordInfoResponse) mockCache.get(cacheKey);
Assertions.assertNotNull(cachedResponse, "缓存响应不能为空");
Assertions.assertEquals(testRecords, cachedResponse.getSumNum().intValue(),
"总记录数应该正确");
Assertions.assertEquals(recordsPerMessage,
cachedResponse.getRecordList().getNum().intValue(), "当前记录数应该正确");
}
// 清理测试数据
for (int i = 0; i < messagesCount; i++) {
String cacheKey = CACHE_KEY_PREFIX + cacheTestCallId + ":part:" + i;
mockCache.remove(cacheKey);
}
System.out.println("✅ 本地缓存聚合机制验证通过");
System.out.println("🎉 本地缓存测试完成！");
}
@Test
@Order(3)
@DisplayName("协议符合性验证：XML格式和字段完整性")
public void testProtocolCompliance() throws Exception {
System.out.println("📋 开始协议符合性验证测试");
// 测试查询请求格式
RecordInfoQuery query = createRecordInfoQuery("34020000001320000001");
String queryXml = XmlUtils.toString("UTF-8", query);
System.out.println("\n📤 验证查询请求XML格式:");
verifyQueryXmlFormat(queryXml);
// 测试响应格式
RecordInfoResponse response = createRecordInfoResponse(
"34020000001320000001", 100, 50, 1, "test-call-id");
String responseXml = XmlUtils.toString("UTF-8", response);
System.out.println("\n📤 验证响应XML格式:");
verifyResponseXmlFormat(responseXml);
// 测试XML序列化/反序列化
System.out.println("\n🔄 验证XML序列化/反序列化:");
verifyXmlSerialization(queryXml, responseXml);
System.out.println("✅ 协议符合性验证完成");
System.out.println("🎉 所有格式验证测试通过！");
}
/**
* 创建录像信息查询请求
*/
private RecordInfoQuery createRecordInfoQuery(String deviceId) {
RecordInfoQuery query = new RecordInfoQuery();
query.setSn("" + System.currentTimeMillis());
query.setDeviceId(deviceId);
query.setStartTime("2023-01-01T00:00:00");
query.setEndTime("2023-12-31T23:59:59");
query.setType("all");
query.setSecrecy(0);
query.setIndistinctQuery("0");
return query;
}
/**
* 创建录像信息响应
*/
private RecordInfoResponse createRecordInfoResponse(String deviceId, int totalRecords,
int currentRecords, int startIndex, String callId) {
RecordInfoResponse response = new RecordInfoResponse();
response.setSn("" + System.currentTimeMillis());
response.setDeviceId(deviceId);
response.setName("测试设备");
response.setSumNum(totalRecords);
RecordInfoResponse.RecordList recordList = new RecordInfoResponse.RecordList();
recordList.setNum(currentRecords);
List<RecordInfoResponse.RecordItem> items = new ArrayList<>();
for (int i = 0; i < currentRecords; i++) {
int recordIndex = startIndex + i;
RecordInfoResponse.RecordItem item = new RecordInfoResponse.RecordItem();
item.setRecordId("record_" + callId + "_" + recordIndex);
item.setName("录像文件" + recordIndex);
item.setFilePath("/records/2023/batch/record_" + recordIndex + ".mp4");
item.setAddress("上海市");
item.setStartTime("2023-01-01T" + String.format("%02d", (recordIndex % 24)) + ":00:00");
item.setEndTime("2023-01-01T" + String.format("%02d", ((recordIndex + 1) % 24)) + ":00:00");
item.setSecrecy(0);
item.setType("time");
item.setRecorderId("recorder_" + (recordIndex % 10 + 1));
item.setFileSize((long) (1024 * 1024 * (50 + recordIndex)));
items.add(item);
}
recordList.setItems(items);
response.setRecordList(recordList);
return response;
}
/**
* 验证本地缓存聚合结果
*/
private void verifyMockCacheAggregation(String callId, int expectedTotalRecords, int expectedMessages) {
System.out.println("\n🔍 验证本地缓存聚合结果");
for (int i = 0; i < expectedMessages; i++) {
String cacheKey = CACHE_KEY_PREFIX + callId + ":part:" + i;
RecordInfoResponse cachedResponse = (RecordInfoResponse) mockCache.get(cacheKey);
if (cachedResponse != null) {
Assertions.assertEquals(expectedTotalRecords, cachedResponse.getSumNum().intValue(),
"缓存中的总记录数应该正确");
System.out.println("✅ 本地缓存验证通过: " + cacheKey);
}
}
}
/**
* 清理模拟缓存
*/
private void clearMockCache() {
mockCache.clear();
}
/**
* 验证查询XML格式
*/
private void verifyQueryXmlFormat(String xml) {
Assertions.assertTrue(xml.contains("<Query>"), "必须包含Query根元素");
Assertions.assertTrue(xml.contains("<CmdType>RecordInfo</CmdType>"), "必须包含CmdType");
Assertions.assertTrue(xml.contains("<SN>"), "必须包含SN");
Assertions.assertTrue(xml.contains("<DeviceID>"), "必须包含DeviceID");
Assertions.assertTrue(xml.contains("<StartTime>"), "必须包含StartTime");
Assertions.assertTrue(xml.contains("<EndTime>"), "必须包含EndTime");
Assertions.assertTrue(xml.contains("<Type>"), "必须包含Type");
System.out.println("✅ 查询XML格式验证通过");
}
/**
* 验证响应XML格式
*/
private void verifyResponseXmlFormat(String xml) {
Assertions.assertTrue(xml.contains("<Response>"), "必须包含Response根元素");
Assertions.assertTrue(xml.contains("<CmdType>RecordInfo</CmdType>"), "必须包含CmdType");
Assertions.assertTrue(xml.contains("<SN>"), "必须包含SN");
Assertions.assertTrue(xml.contains("<DeviceID>"), "必须包含DeviceID");
Assertions.assertTrue(xml.contains("<Name>"), "必须包含Name");
Assertions.assertTrue(xml.contains("<SumNum>"), "必须包含SumNum");
Assertions.assertTrue(xml.contains("<RecordList"), "必须包含RecordList");
Assertions.assertTrue(xml.contains("Num="), "RecordList必须包含Num属性");
System.out.println("✅ 响应XML格式验证通过");
}
/**
* 验证XML序列化/反序列化
*/
private void verifyXmlSerialization(String queryXml, String responseXml) {
try {
RecordInfoQuery parsedQuery = (RecordInfoQuery) XmlUtils.parseObj(queryXml, RecordInfoQuery.class);
Assertions.assertNotNull(parsedQuery, "查询应该能够被正确解析");
Assertions.assertEquals(RECORD_INFO_CMD_TYPE, parsedQuery.getCmdType(), "查询CmdType应该正确");
RecordInfoResponse parsedResponse = (RecordInfoResponse) XmlUtils.parseObj(responseXml, RecordInfoResponse.class);
Assertions.assertNotNull(parsedResponse, "响应应该能够被正确解析");
Assertions.assertEquals(RECORD_INFO_CMD_TYPE, parsedResponse.getCmdType(), "响应CmdType应该正确");
System.out.println("✅ XML序列化/反序列化验证通过");
} catch (Exception e) {
Assertions.fail("XML序列化/反序列化失败: " + e.getMessage());
}
}
@AfterEach
@Override
public void tearDown() {
super.tearDown();
// 清理模拟缓存
clearMockCache();
System.out.println("🧹 清理录像检索测试状态");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/ServerDeviceControlCommandTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/ServerDeviceControlCommandTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gb28181.common.entity.control.*;
import io.github.lunasaw.gbproxy.server.transmit.cmd.ServerSendCmd;
import io.github.lunasaw.gbproxy.test.handler.TestDeviceControlRequestHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import java.util.concurrent.TimeUnit;
/**
* 端到端测试：服务端DeviceControl控制命令
* 验证服务端主动发起各类控制命令，客户端能正确接收并执行业务处理
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class ServerDeviceControlCommandTest extends BasicSipCommonTest {
@Test
@Order(1)
@DisplayName("测试 PTZ 云台控制命令")
public void testDeviceControlPtz() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlPtz ptzCmd = new DeviceControlPtz("DeviceControl", "1001", serverToDevice.getUserId());
ptzCmd.setPtzCmd("A50F0100"); // 示例PTZ命令
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, ptzCmd);
Assertions.assertNotNull(callId, "callId不能为空");
// 补充断言
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForPtz(5, TimeUnit.SECONDS), "PTZ命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedPtz(), "PTZ命令对象未接收");
DeviceControlPtz received = TestDeviceControlRequestHandler.getReceivedPtz();
Assertions.assertNotNull(received, "PTZ命令对象为空");
Assertions.assertEquals(ptzCmd.getPtzCmd(), received.getPtzCmd(), "PTZ命令内容不一致");
}
@Test
@Order(2)
@DisplayName("测试 Guard 布防/撤防命令")
public void testDeviceControlGuard() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlGuard guardCmd = new DeviceControlGuard("DeviceControl", "1002", serverToDevice.getUserId());
guardCmd.setGuardCmd("SetGuard");
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, guardCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForGuard(5, TimeUnit.SECONDS), "Guard命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedGuard(), "Guard命令对象未接收");
DeviceControlGuard received = TestDeviceControlRequestHandler.getReceivedGuard();
Assertions.assertNotNull(received, "Guard命令对象为空");
Assertions.assertEquals(guardCmd.getGuardCmd(), received.getGuardCmd(), "Guard命令内容不一致");
}
@Test
@Order(3)
@DisplayName("测试 Alarm 告警复位命令")
public void testDeviceControlAlarm() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlAlarm alarmCmd = new DeviceControlAlarm("DeviceControl", "1003", serverToDevice.getUserId());
alarmCmd.setAlarmCmd("ResetAlarm");
alarmCmd.setAlarmInfo(new DeviceControlAlarm.AlarmInfo("method", "type"));
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, alarmCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForAlarm(5, TimeUnit.SECONDS), "Alarm命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedAlarm(), "Alarm命令对象未接收");
DeviceControlAlarm received = TestDeviceControlRequestHandler.getReceivedAlarm();
Assertions.assertNotNull(received, "Alarm命令对象为空");
Assertions.assertEquals(alarmCmd.getAlarmCmd(), received.getAlarmCmd(), "Alarm命令内容不一致");
Assertions.assertNotNull(received.getAlarmInfo(), "AlarmInfo为空");
Assertions.assertEquals(alarmCmd.getAlarmInfo().getAlarmMethod(), received.getAlarmInfo().getAlarmMethod(), "AlarmInfo method不一致");
Assertions.assertEquals(alarmCmd.getAlarmInfo().getAlarmType(), received.getAlarmInfo().getAlarmType(), "AlarmInfo type不一致");
}
@Test
@Order(4)
@DisplayName("测试 TeleBoot 远程启动命令")
public void testDeviceControlTeleBoot() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlTeleBoot teleBootCmd = new DeviceControlTeleBoot("DeviceControl", "1004", serverToDevice.getUserId());
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, teleBootCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForTeleBoot(5, TimeUnit.SECONDS), "TeleBoot命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedTeleBoot(), "TeleBoot命令对象未接收");
DeviceControlTeleBoot received = TestDeviceControlRequestHandler.getReceivedTeleBoot();
Assertions.assertNotNull(received, "TeleBoot命令对象为空");
}
@Test
@Order(5)
@DisplayName("测试 RecordCmd 录像控制命令")
public void testDeviceControlRecordCmd() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlRecordCmd recordCmd = new DeviceControlRecordCmd("DeviceControl", "1005", serverToDevice.getUserId());
recordCmd.setRecordCmd("Record");
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, recordCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForRecord(5, TimeUnit.SECONDS), "Record命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedRecord(), "Record命令对象未接收");
DeviceControlRecordCmd received = TestDeviceControlRequestHandler.getReceivedRecord();
Assertions.assertNotNull(received, "Record命令对象为空");
Assertions.assertEquals(recordCmd.getRecordCmd(), received.getRecordCmd(), "Record命令内容不一致");
}
@Test
@Order(6)
@DisplayName("测试 IFameCmd 强制关键帧命令")
public void testDeviceControlIFame() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlIFame iFameCmd = new DeviceControlIFame("DeviceControl", "1006", serverToDevice.getUserId());
iFameCmd.setIFameCmd("Send");
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, iFameCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForIFame(5, TimeUnit.SECONDS), "IFame命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedIFame(), "IFame命令对象未接收");
DeviceControlIFame received = TestDeviceControlRequestHandler.getReceivedIFame();
Assertions.assertNotNull(received, "IFame命令对象为空");
Assertions.assertEquals(iFameCmd.getIFameCmd(), received.getIFameCmd(), "IFame命令内容不一致");
}
@Test
@Order(7)
@DisplayName("测试 DragZoomIn 拉框放大命令")
public void testDeviceControlDragIn() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlDragIn dragInCmd = new DeviceControlDragIn("DeviceControl", "1007", serverToDevice.getUserId());
dragInCmd.setDragZoomIn(new DragZoom("100", "200", "50", "50", "80", "80"));
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, dragInCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForDragIn(5, TimeUnit.SECONDS), "DragIn命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedDragIn(), "DragIn命令对象未接收");
DeviceControlDragIn received = TestDeviceControlRequestHandler.getReceivedDragIn();
Assertions.assertNotNull(received, "DragIn命令对象为空");
Assertions.assertNotNull(received.getDragZoomIn(), "DragZoomIn内容为空");
Assertions.assertEquals(dragInCmd.getDragZoomIn().getLengthX(), received.getDragZoomIn().getLengthX(), "DragZoomIn X不一致");
}
@Test
@Order(8)
@DisplayName("测试 DragZoomOut 拉框缩小命令")
public void testDeviceControlDragOut() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlDragOut dragOutCmd = new DeviceControlDragOut("DeviceControl", "1008", serverToDevice.getUserId());
dragOutCmd.setDragZoomOut(new DragZoom("100", "200", "50", "50", "80", "80"));
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, dragOutCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForDragOut(5, TimeUnit.SECONDS), "DragOut命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedDragOut(), "DragOut命令对象未接收");
DeviceControlDragOut received = TestDeviceControlRequestHandler.getReceivedDragOut();
Assertions.assertNotNull(received, "DragOut命令对象为空");
Assertions.assertNotNull(received.getDragZoomOut(), "DragZoomOut内容为空");
Assertions.assertEquals(dragOutCmd.getDragZoomOut().getLengthX(), received.getDragZoomOut().getLengthX(), "DragZoomOut X不一致");
}
@Test
@Order(9)
@DisplayName("测试 HomePosition 看守位命令")
public void testDeviceControlHomePosition() throws Exception {
TestDeviceControlRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
DeviceControlPosition homePositionCmd = new DeviceControlPosition("DeviceControl", "1009", serverToDevice.getUserId());
homePositionCmd.setHomePosition(new DeviceControlPosition.HomePosition("1", "60", "2"));
String callId = ServerSendCmd.deviceControl(serverFromDevice, serverToDevice, homePositionCmd);
Assertions.assertNotNull(callId, "callId不能为空");
Assertions.assertTrue(TestDeviceControlRequestHandler.waitForHomePosition(5, TimeUnit.SECONDS), "HomePosition命令未收到");
Assertions.assertTrue(TestDeviceControlRequestHandler.hasReceivedHomePosition(), "HomePosition命令对象未接收");
DeviceControlPosition received = TestDeviceControlRequestHandler.getReceivedHomePosition();
Assertions.assertNotNull(received, "HomePosition命令对象为空");
Assertions.assertNotNull(received.getHomePosition(), "HomePosition内容为空");
Assertions.assertEquals(homePositionCmd.getHomePosition().getPresetIndex(), received.getHomePosition().getPresetIndex(), "HomePosition PresetIndex不一致");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/SipProxyIntegrationTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/SipProxyIntegrationTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.client.Gb28181Client;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.gbproxy.server.Gb28181Server;
import io.github.lunasaw.gbproxy.test.config.TestDeviceSupplier;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.layer.SipLayer;
import io.github.lunasaw.sip.common.service.DeviceSupplier;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.transmit.event.Event;
import io.github.lunasaw.sip.common.transmit.event.EventResult;
import io.github.lunasaw.sip.common.utils.SipRequestUtils;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* SIP代理集成测试类
* 测试SIP协议栈、设备管理、消息传输等核心功能
*
* @author luna
* @date 2025/01/23
*/
@Slf4j
@SpringBootTest(classes = Gb28181ApplicationTest.class)
@TestPropertySource(properties = {
"sip.gb28181.server.ip=0.0.0.0",
"sip.gb28181.server.port=5060",
"sip.gb28181.server.domain=34020000002000000001",
"sip.gb28181.server.serverId=34020000002000000001",
"sip.gb28181.server.serverName=GB28181-Server",
"sip.gb28181.server.maxDevices=1000",
"sip.gb28181.server.deviceTimeout=5m",
"sip.gb28181.server.enableTcp=true",
"sip.gb28181.server.enableUdp=true",
"sip.gb28181.client.keepAliveInterval=1m",
"sip.gb28181.client.maxRetries=3",
"sip.gb28181.client.retryDelay=5s",
"sip.gb28181.client.registerExpires=3600",
"sip.gb28181.client.clientId=34020000001320000001",
"sip.gb28181.client.clientName=GB28181-Client",
"sip.gb28181.client.username=admin",
"sip.gb28181.client.password=123456",
"sip.performance.messageQueueSize=1000",
"sip.performance.threadPoolSize=200",
"sip.performance.enableMetrics=true",
"sip.performance.enableAsync=true",
"sip.async.enabled=true",
"sip.async.corePoolSize=4",
"sip.async.maxPoolSize=8",
"sip.cache.enabled=true",
"sip.cache.maxSize=1000",
"sip.cache.expireAfterWrite=1h",
"sip.pool.enabled=true",
"sip.pool.maxConnections=100",
"sip.pool.coreConnections=10"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class SipProxyIntegrationTest {
@Autowired
private SipLayer sipLayer;
@Autowired
private TestDeviceSupplier testDeviceSupplier;
private CountDownLatch responseLatch;
@BeforeEach
public void setUp() {
// 获取客户端设备
FromDevice clientFromDevice = testDeviceSupplier.getClientFromDevice();
if (clientFromDevice == null) {
log.error("未找到客户端设备配置");
return;
}
// 设置监听点
responseLatch = new CountDownLatch(1);
}
@Test
@Order(1)
@DisplayName("测试SIP层初始化")
public void testSipLayerInitialization() {
Assertions.assertNotNull(sipLayer, "SIP层应该被正确初始化");
// 获取设备
FromDevice clientFromDevice = testDeviceSupplier.getClientFromDevice();
ToDevice clientToDevice = testDeviceSupplier.getClientToDevice();
Assertions.assertNotNull(clientFromDevice, "客户端设备应该被正确配置");
Assertions.assertNotNull(clientToDevice, "服务端设备应该被正确配置");
System.out.println("=== SIP层初始化测试通过 ===");
System.out.println("客户端设备: " + clientFromDevice.getUserId() + ":" + clientFromDevice.getPort());
System.out.println("服务端设备: " + clientToDevice.getUserId() + ":" + clientToDevice.getPort());
sipLayer.addListeningPoint(clientFromDevice.getIp(), clientFromDevice.getPort());
}
@Test
@Order(2)
@DisplayName("测试设备注册")
public void testDeviceRegistration() throws Exception {
// 获取设备
FromDevice clientFromDevice = testDeviceSupplier.getClientFromDevice();
ToDevice clientToDevice = testDeviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
log.error("未找到设备配置");
return;
}
String resultCallId = ClientCommandSender.sendRegisterCommand(clientFromDevice, clientToDevice, 3600);
System.out.println("=== 开始设备注册测试 ===");
System.out.println("注册请求CallId: " + resultCallId);
System.out.println("注册请求From: " + clientFromDevice.getUserId());
System.out.println("注册请求To: " + clientToDevice.getUserId());
// 在测试环境中，我们只验证请求能够发送
Assertions.assertNotNull(resultCallId, "注册请求已发送");
}
@Test
@Order(3)
@DisplayName("测试设备心跳")
public void testDeviceHeartbeat() throws Exception {
// 获取设备
FromDevice clientFromDevice = testDeviceSupplier.getClientFromDevice();
ToDevice clientToDevice = testDeviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
log.error("未找到设备配置");
return;
}
String heartbeatContent = "<?xml version=\"1.0\"?>\n" +
"<Control>\n" +
" <CmdType>Keepalive</CmdType>\n" +
" <SN>1</SN>\n" +
" <DeviceID>" + clientFromDevice.getUserId() + "</DeviceID>\n" +
"</Control>";
System.out.println("=== 开始设备心跳测试 ===");
String resultCallId = ClientCommandSender.sendKeepaliveCommand(clientFromDevice, clientToDevice, "onLine");
System.out.println("心跳请求CallId: " + resultCallId);
// 心跳测试主要验证请求能够发送
Assertions.assertNotNull(resultCallId, "心跳请求已发送");
}
@Test
@Order(4)
@DisplayName("测试设备目录查询")
public void testDeviceCatalogQuery() throws Exception {
// 获取设备
FromDevice clientFromDevice = testDeviceSupplier.getClientFromDevice();
ToDevice clientToDevice = testDeviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
log.error("未找到设备配置");
return;
}
String catalogContent = "<?xml version=\"1.0\"?>\n" +
"<Query>\n" +
" <CmdType>Catalog</CmdType>\n" +
" <SN>2</SN>\n" +
" <DeviceID>" + clientFromDevice.getUserId() + "</DeviceID>\n" +
"</Query>";
System.out.println("=== 开始设备目录查询测试 ===");
String resultCallId = ClientCommandSender.sendCommand("MESSAGE", clientFromDevice, clientToDevice, catalogContent);
System.out.println("目录查询CallId: " + resultCallId);
Assertions.assertNotNull(resultCallId, "目录查询请求已发送");
}
@Test
@Order(5)
@DisplayName("测试设备配置验证")
public void testDeviceConfiguration() {
System.out.println("=== 设备配置验证测试 ===");
// 获取设备
FromDevice clientFromDevice = testDeviceSupplier.getClientFromDevice();
ToDevice clientToDevice = testDeviceSupplier.getClientToDevice();
// 验证客户端设备配置
Assertions.assertNotNull(clientFromDevice.getUserId(), "客户端设备ID不能为空");
Assertions.assertNotNull(clientFromDevice.getIp(), "客户端设备IP不能为空");
Assertions.assertTrue(clientFromDevice.getPort() > 0, "客户端设备端口必须大于0");
// 验证服务端设备配置
Assertions.assertNotNull(clientToDevice.getUserId(), "服务端设备ID不能为空");
Assertions.assertNotNull(clientToDevice.getIp(), "服务端设备IP不能为空");
Assertions.assertTrue(clientToDevice.getPort() > 0, "服务端设备端口必须大于0");
System.out.println("客户端设备配置: " + clientFromDevice.getUserId() + "@" + clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
System.out.println("服务端设备配置: " + clientToDevice.getUserId() + "@" + clientToDevice.getIp() + ":" + clientToDevice.getPort());
// 验证设备类型
Assertions.assertTrue(clientFromDevice instanceof FromDevice, "客户端设备应该是FromDevice类型");
Assertions.assertTrue(clientToDevice instanceof ToDevice, "服务端设备应该是ToDevice类型");
}
@AfterEach
public void tearDown() {
// 清理资源
if (responseLatch != null) {
responseLatch.countDown();
}
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/SipProxyBasicTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/SipProxyBasicTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.gbproxy.test.config.TestDeviceSupplier;
import io.github.lunasaw.gbproxy.test.utils.TestSipRequestUtils;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.service.DeviceSupplier;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import java.util.List;
/**
* SIP代理基础功能测试
* 用于快速验证SIP代理的基本功能
*
* 已改造为使用TestDeviceSupplier的新转换方法：
* - 使用 getClientFromDevice() 获取客户端From设备
* - 使用 getClientToDevice() 获取客户端To设备
* - 使用 getServerFromDevice() 获取服务端From设备
* - 使用 getServerToDevice() 获取服务端To设备
*
* @author luna
* @date 2024/01/01
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class,
webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.org.springframework=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class SipProxyBasicTest {
@Autowired(required = false)
private TestDeviceSupplier deviceSupplier;
private FromDevice clientFromDevice;
private ToDevice clientToDevice;
@BeforeEach
public void setUp() {
System.out.println("=== 开始SIP代理基础测试 ===");
// 检查设备提供器是否可用
if (deviceSupplier == null) {
System.out.println("警告: 设备提供器未注入，跳过设备相关测试");
return;
}
try {
// 使用新的转换方法获取设备
clientFromDevice = deviceSupplier.getClientFromDevice();
clientToDevice = deviceSupplier.getClientToDevice();
System.out.println("设备获取完成");
} catch (Exception e) {
System.err.println("设备获取失败: " + e.getMessage());
e.printStackTrace();
}
}
@Test
@Order(1)
@DisplayName("测试Spring上下文加载")
public void testSpringContextLoads() {
// 基本Spring上下文测试
Assertions.assertTrue(true, "Spring上下文应该能够加载");
System.out.println("Spring上下文加载成功");
}
@Test
@Order(2)
@DisplayName("测试设备提供器注入")
public void testDeviceSupplierInjection() {
if (deviceSupplier == null) {
System.out.println("跳过设备提供器测试 - 未注入");
return;
}
Assertions.assertNotNull(deviceSupplier, "设备提供器应该被正确注入");
System.out.println("设备提供器注入成功: " + deviceSupplier.getClass().getSimpleName());
}
@Test
@Order(3)
@DisplayName("测试设备获取")
public void testDeviceRetrieval() {
if (deviceSupplier == null) {
System.out.println("跳过设备获取测试 - 设备提供器未注入");
return;
}
try {
// 测试设备获取 - 使用新的转换方法
FromDevice fromDevice = deviceSupplier.getClientFromDevice();
ToDevice toDevice = deviceSupplier.getClientToDevice();
if (fromDevice != null) {
Assertions.assertNotNull(fromDevice.getUserId(), "From设备ID不能为空");
System.out.println("From设备获取成功: " + fromDevice.getUserId());
}
if (toDevice != null) {
Assertions.assertNotNull(toDevice.getUserId(), "To设备ID不能为空");
System.out.println("To设备获取成功: " + toDevice.getUserId());
}
} catch (Exception e) {
System.err.println("设备获取测试失败: " + e.getMessage());
e.printStackTrace();
}
}
@Test
@Order(4)
@DisplayName("测试SIP注册请求创建")
public void testCreateRegisterRequest() {
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("跳过SIP请求测试 - 设备未获取");
return;
}
try {
String resultCallId = ClientCommandSender.sendRegisterCommand(clientFromDevice, clientToDevice, 3600);
Assertions.assertNotNull(resultCallId, "注册请求应该被成功创建");
System.out.println("注册请求创建成功");
System.out.println("CallId: " + resultCallId);
System.out.println("From: " + clientFromDevice.getUserId());
System.out.println("To: " + clientToDevice.getUserId());
} catch (Exception e) {
System.err.println("SIP请求创建失败: " + e.getMessage());
e.printStackTrace();
}
}
@Test
@Order(5)
@DisplayName("测试SIP消息请求创建")
public void testCreateMessageRequest() {
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("跳过SIP消息测试 - 设备未获取");
return;
}
try {
String callId = TestSipRequestUtils.getNewCallId();
String xmlContent = "<?xml version=\"1.0\"?>\n" +
"<Control>\n" +
" <CmdType>Keepalive</CmdType>\n" +
" <SN>1</SN>\n" +
" <DeviceID>" + clientFromDevice.getUserId() + "</DeviceID>\n" +
"</Control>";
String resultCallId = ClientCommandSender.sendCommand("MESSAGE", clientFromDevice, clientToDevice, xmlContent);
Assertions.assertNotNull(resultCallId, "消息请求应该被成功创建");
System.out.println("消息请求创建成功");
System.out.println("CallId: " + resultCallId);
System.out.println("Content: " + xmlContent);
} catch (Exception e) {
System.err.println("SIP消息创建失败: " + e.getMessage());
e.printStackTrace();
}
}
@Test
@Order(6)
@DisplayName("测试设备配置")
public void testDeviceConfiguration() {
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("跳过设备配置测试 - 设备未获取");
return;
}
try {
// 验证客户端From设备
Assertions.assertNotNull(clientFromDevice.getUserId(), "From设备ID不能为空");
Assertions.assertNotNull(clientFromDevice.getIp(), "From设备IP不能为空");
Assertions.assertTrue(clientFromDevice.getPort() > 0, "From设备端口必须大于0");
Assertions.assertNotNull(clientFromDevice.getFromTag(), "FromTag不能为空");
Assertions.assertNotNull(clientFromDevice.getAgent(), "Agent不能为空");
// 验证客户端To设备
Assertions.assertNotNull(clientToDevice.getUserId(), "To设备ID不能为空");
Assertions.assertNotNull(clientToDevice.getIp(), "To设备IP不能为空");
Assertions.assertTrue(clientToDevice.getPort() > 0, "To设备端口必须大于0");
System.out.println("From设备配置: " + clientFromDevice.getUserId() + "@" + clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
System.out.println("To设备配置: " + clientToDevice.getUserId() + "@" + clientToDevice.getIp() + ":" + clientToDevice.getPort());
System.out.println("FromTag: " + clientFromDevice.getFromTag());
System.out.println("Agent: " + clientFromDevice.getAgent());
} catch (Exception e) {
System.err.println("设备配置测试失败: " + e.getMessage());
e.printStackTrace();
}
}
@Test
@Order(7)
@DisplayName("测试SIP请求工具类")
public void testSipRequestUtils() {
try {
// 测试CallId生成
String callId1 = TestSipRequestUtils.getNewCallId();
String callId2 = TestSipRequestUtils.getNewCallId();
Assertions.assertNotNull(callId1, "CallId不能为空");
Assertions.assertNotNull(callId2, "CallId不能为空");
Assertions.assertNotEquals(callId1, callId2, "生成的CallId应该不同");
System.out.println("SIP请求工具类测试通过");
System.out.println("CallId1: " + callId1);
System.out.println("CallId2: " + callId2);
} catch (Exception e) {
System.err.println("SIP请求工具类测试失败: " + e.getMessage());
e.printStackTrace();
}
}
@Test
@Order(8)
@DisplayName("测试设备用户ID映射")
public void testDeviceUserIdMapping() {
if (deviceSupplier == null) {
System.out.println("跳过设备用户ID映射测试 - 设备提供器未注入");
return;
}
try {
// 测试所有设备用户ID - 使用新的转换方法
String[] userIds = {"33010602011187000001", "41010500002000000001"};
for (String userId : userIds) {
Device device = deviceSupplier.getDevice(userId);
if (device != null) {
System.out.println("用户ID " + userId + " 获取成功: " + device.getUserId());
} else {
System.out.println("用户ID " + userId + " 未找到设备");
}
}
// 测试转换方法
FromDevice fromDevice = deviceSupplier.getClientFromDevice();
ToDevice toDevice = deviceSupplier.getClientToDevice();
if (fromDevice != null) {
System.out.println("客户端From设备: " + fromDevice.getUserId());
}
if (toDevice != null) {
System.out.println("客户端To设备: " + toDevice.getUserId());
}
System.out.println("设备用户ID映射测试完成");
} catch (Exception e) {
System.err.println("设备用户ID映射测试失败: " + e.getMessage());
e.printStackTrace();
}
}
@AfterEach
public void tearDown() {
System.out.println("=== SIP代理基础测试完成 ===");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/ClientCommandSenderAllTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/ClientCommandSenderAllTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gb28181.common.entity.DeviceAlarm;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceAlarmNotify;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceKeepLiveNotify;
import io.github.lunasaw.gb28181.common.entity.response.*;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.gbproxy.test.handler.TestServerMessageProcessorHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import java.util.concurrent.TimeUnit;
/**
* 系统性测试ClientCommandSender所有指令
* 参考testSendMessageRequest风格，断言完整
*
* @author AI
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class ClientCommandSenderAllTest extends BasicSipCommonTest {
@Test
@Order(1)
@DisplayName("测试sendKeepaliveCommand（字符串）")
public void testSendKeepaliveCommandString() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
String callId = ClientCommandSender.sendKeepaliveCommand(clientFromDevice, clientToDevice, "onLine");
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForKeepalive(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到心跳");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedKeepalive(), "服务端应成功接收心跳");
var receivedKeepalive = TestServerMessageProcessorHandler.getReceivedKeepalive();
Assertions.assertNotNull(receivedKeepalive, "心跳内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedKeepalive.getDeviceId(), "设备ID应一致");
}
@Test
@Order(2)
@DisplayName("测试sendKeepaliveCommand（DeviceKeepLiveNotify）")
public void testSendKeepaliveCommandNotify() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
DeviceKeepLiveNotify notify = new DeviceKeepLiveNotify();
notify.setDeviceId(clientFromDevice.getUserId());
notify.setStatus("ON");
String callId = ClientCommandSender.sendKeepaliveCommand(clientFromDevice, clientToDevice, notify);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForKeepalive(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到心跳");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedKeepalive(), "服务端应成功接收心跳");
var receivedKeepalive = TestServerMessageProcessorHandler.getReceivedKeepalive();
Assertions.assertNotNull(receivedKeepalive, "心跳内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedKeepalive.getDeviceId(), "设备ID应一致");
}
@Test
@Order(3)
@DisplayName("测试sendAlarmCommand（DeviceAlarmNotify）")
public void testSendAlarmCommandNotify() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
// 构造DeviceAlarm对象，设置丰富字段
DeviceAlarm deviceAlarm = new DeviceAlarm();
deviceAlarm.setDeviceId(clientFromDevice.getUserId());
deviceAlarm.setAlarmPriority("1"); // 一级警情
deviceAlarm.setAlarmMethod("2"); // 设备报警
deviceAlarm.setAlarmTime(new java.util.Date());
deviceAlarm.setAlarmDescription("测试报警信息");
deviceAlarm.setLongitude(120.123456);
deviceAlarm.setLatitude(30.123456);
deviceAlarm.setAlarmType("1"); // 1-视频丢失报警
// 构造DeviceAlarmNotify并用setAlarm填充
DeviceAlarmNotify alarmNotify = new DeviceAlarmNotify();
alarmNotify.setCmdType("Alarm");
alarmNotify.setSn("123456");
alarmNotify.setDeviceId(clientFromDevice.getUserId());
alarmNotify.setAlarm(deviceAlarm);
String callId = ClientCommandSender.sendAlarmCommand(clientFromDevice, clientToDevice, alarmNotify);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForAlarm(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到报警");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedAlarm(), "服务端应成功接收报警");
var receivedAlarm = TestServerMessageProcessorHandler.getReceivedAlarm();
Assertions.assertNotNull(receivedAlarm, "报警内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedAlarm.getDeviceId(), "设备ID应一致");
}
@Test
@Order(4)
@DisplayName("测试sendCatalogCommand（DeviceResponse）")
public void testSendCatalogCommandResponse() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
// 构造DeviceResponse，设置完整字段
DeviceResponse response = new DeviceResponse();
response.setCmdType("Catalog");
response.setSn("654321");
response.setDeviceId(clientFromDevice.getUserId());
response.setSumNum(2);
// 构造DeviceItem列表
DeviceItem item1 = new DeviceItem();
item1.setDeviceId(clientFromDevice.getUserId());
item1.setName("测试通道1");
item1.setManufacturer("测试厂商A");
item1.setModel("Model-A");
item1.setOwner("AdminA");
item1.setCivilCode("440501");
item1.setAddress("测试地址A");
item1.setParental(0);
item1.setParentId("0");
item1.setSafetyWay(0);
item1.setRegisterWay(1);
item1.setSecrecy(0);
item1.setStatus("ON");
item1.setBlock("BlockA");
item1.setCertNum("CertNumA");
item1.setCertifiable(1);
item1.setErrCode(0);
item1.setEndTime("2099-01-01T01:01:01");
item1.setIpAddress("192.168.1.101");
item1.setPort(5060);
item1.setPassword("passA");
item1.setPtzType(1);
item1.setLongitude(121.472644);
item1.setLatitude(31.231706);
DeviceItem item2 = new DeviceItem();
item2.setDeviceId(clientFromDevice.getUserId().substring(0, 18) + "02");
item2.setName("测试通道2");
item2.setManufacturer("测试厂商B");
item2.setModel("Model-B");
item2.setOwner("AdminB");
item2.setCivilCode("440502");
item2.setAddress("测试地址B");
item2.setParental(0);
item2.setParentId("0");
item2.setSafetyWay(0);
item2.setRegisterWay(1);
item2.setSecrecy(0);
item2.setStatus("OFF");
item2.setBlock("BlockB");
item2.setCertNum("CertNumB");
item2.setCertifiable(0);
item2.setErrCode(1);
item2.setEndTime("2099-12-31T23:59:59");
item2.setIpAddress("192.168.1.102");
item2.setPort(5061);
item2.setPassword("passB");
item2.setPtzType(2);
item2.setLongitude(120.123456);
item2.setLatitude(30.123456);
response.setDeviceItemList(java.util.Arrays.asList(item1, item2));
String callId = ClientCommandSender.sendCatalogCommand(clientFromDevice, clientToDevice, response);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForCatalog(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到目录");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedCatalog(), "服务端应成功接收目录");
var receivedCatalog = TestServerMessageProcessorHandler.getReceivedCatalog();
Assertions.assertNotNull(receivedCatalog, "目录内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedCatalog.getDeviceId(), "设备ID应一致");
}
@Test
@Order(6)
@DisplayName("测试sendDeviceInfoCommand")
public void testSendDeviceInfoCommand() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
DeviceInfo info = new DeviceInfo();
info.setDeviceId(clientFromDevice.getUserId());
String callId = ClientCommandSender.sendDeviceInfoCommand(clientFromDevice, clientToDevice, info);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForDeviceInfo(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到设备信息");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedDeviceInfo(), "服务端应成功接收设备信息");
var receivedInfo = TestServerMessageProcessorHandler.getReceivedDeviceInfo();
Assertions.assertNotNull(receivedInfo, "设备信息内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedInfo.getDeviceId(), "设备ID应一致");
}
@Test
@Order(7)
@DisplayName("测试sendDeviceStatusCommand（字符串）")
public void testSendDeviceStatusCommandString() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
String callId = ClientCommandSender.sendDeviceStatusCommand(clientFromDevice, clientToDevice, "ON");
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForDeviceStatus(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到设备状态");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedDeviceStatus(), "服务端应成功接收设备状态");
var receivedStatus = TestServerMessageProcessorHandler.getReceivedDeviceStatus();
Assertions.assertNotNull(receivedStatus, "设备状态内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedStatus.getDeviceId(), "设备ID应一致");
}
@Test
@Order(8)
@DisplayName("测试sendDeviceStatusCommand（DeviceStatus）")
public void testSendDeviceStatusCommandEntity() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
DeviceStatus status = new DeviceStatus();
status.setDeviceId(clientFromDevice.getUserId());
status.setOnline("ON");
String callId = ClientCommandSender.sendDeviceStatusCommand(clientFromDevice, clientToDevice, status);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForDeviceStatus(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到设备状态");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedDeviceStatus(), "服务端应成功接收设备状态");
var receivedStatus = TestServerMessageProcessorHandler.getReceivedDeviceStatus();
Assertions.assertNotNull(receivedStatus, "设备状态内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedStatus.getDeviceId(), "设备ID应一致");
}
@Test
@Order(9)
@DisplayName("测试sendDeviceRecordCommand")
public void testSendDeviceRecordCommand() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
DeviceRecord record = new DeviceRecord();
record.setDeviceId(clientFromDevice.getUserId());
String callId = ClientCommandSender.sendDeviceRecordCommand(clientFromDevice, clientToDevice, record);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForDeviceRecord(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到录像信息");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedDeviceRecord(), "服务端应成功接收录像信息");
var receivedRecord = TestServerMessageProcessorHandler.getReceivedDeviceRecord();
Assertions.assertNotNull(receivedRecord, "录像内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedRecord.getDeviceId(), "设备ID应一致");
}
@Test
@Order(10)
@DisplayName("测试sendDeviceConfigCommand")
public void testSendDeviceConfigCommand() throws Exception {
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
DeviceConfigResponse config = new DeviceConfigResponse();
config.setDeviceId(clientFromDevice.getUserId());
String callId = ClientCommandSender.sendDeviceConfigCommand(clientFromDevice, clientToDevice, config);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestServerMessageProcessorHandler.waitForDeviceConfig(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "服务端应收到设备配置");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedDeviceConfig(), "服务端应成功接收设备配置");
var receivedConfig = TestServerMessageProcessorHandler.getReceivedDeviceConfig();
Assertions.assertNotNull(receivedConfig, "设备配置内容不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedConfig.getDeviceId(), "设备ID应一致");
}
// 其他如sendByeCommand、sendAckCommand、sendRegisterCommand、sendUnregisterCommand等指令
// 可根据实际服务端处理能力和断言方式补充
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/SipProxyTestRunner.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/SipProxyTestRunner.java | package io.github.lunasaw.gbproxy.test;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
/**
* SIP代理测试运行器
* 统一管理所有测试的执行，提供测试分类和执行顺序
*
* @author luna
* @date 2025/01/23
*/
@Slf4j
@SpringBootTest(classes = Gb28181ApplicationTest.class)
@TestPropertySource(properties = {
// 服务端配置
"sip.gb28181.server.ip=0.0.0.0",
"sip.gb28181.server.port=5060",
"sip.gb28181.server.domain=34020000002000000001",
"sip.gb28181.server.serverId=34020000002000000001",
"sip.gb28181.server.serverName=GB28181-Server",
"sip.gb28181.server.maxDevices=1000",
"sip.gb28181.server.deviceTimeout=5m",
"sip.gb28181.server.enableTcp=true",
"sip.gb28181.server.enableUdp=true",
// 客户端配置
"sip.gb28181.client.keepAliveInterval=1m",
"sip.gb28181.client.maxRetries=3",
"sip.gb28181.client.retryDelay=5s",
"sip.gb28181.client.registerExpires=3600",
"sip.gb28181.client.clientId=34020000001320000001",
"sip.gb28181.client.clientName=GB28181-Client",
"sip.gb28181.client.username=admin",
"sip.gb28181.client.password=123456",
// 性能配置
"sip.performance.messageQueueSize=1000",
"sip.performance.threadPoolSize=200",
"sip.performance.enableMetrics=true",
"sip.performance.enableAsync=true",
// 异步配置
"sip.async.enabled=true",
"sip.async.corePoolSize=4",
"sip.async.maxPoolSize=8",
// 缓存配置
"sip.cache.enabled=true",
"sip.cache.maxSize=1000",
"sip.cache.expireAfterWrite=1h",
// 连接池配置
"sip.pool.enabled=true",
"sip.pool.maxConnections=100",
"sip.pool.coreConnections=10"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class SipProxyTestRunner {
@Test
@Order(1)
@DisplayName("测试环境初始化验证")
public void testEnvironmentInitialization() {
System.out.println("=== SIP代理测试环境初始化验证 ===");
System.out.println("测试环境配置验证通过");
System.out.println("客户端和服务端配置已加载");
System.out.println("性能、异步、缓存、连接池配置已生效");
// 验证测试环境配置
Assertions.assertTrue(true, "测试环境应该被正确初始化");
}
@Test
@Order(2)
@DisplayName("测试分类说明")
public void testClassificationDescription() {
System.out.println("=== SIP代理测试分类说明 ===");
System.out.println("客户端测试类：");
System.out.println(" - ClientRegisterTest: 设备注册功能测试");
System.out.println(" - ClientHeartbeatTest: 设备心跳功能测试");
System.out.println(" - ClientCatalogTest: 设备目录查询功能测试");
System.out.println(" - ClientControlTest: 设备控制响应功能测试");
System.out.println(" - ClientInviteTest: 设备点播响应功能测试");
System.out.println();
System.out.println("服务端测试类：");
System.out.println(" - ServerRegisterTest: 设备注册管理功能测试");
System.out.println(" - ServerHeartbeatTest: 设备心跳监控功能测试");
System.out.println(" - ServerCatalogTest: 设备目录查询功能测试");
System.out.println(" - ServerControlTest: 设备控制命令功能测试");
System.out.println(" - ServerInviteTest: 设备点播命令功能测试");
System.out.println();
System.out.println("测试执行建议：");
System.out.println(" 1. 先运行客户端测试，验证设备端功能");
System.out.println(" 2. 再运行服务端测试，验证平台端功能");
System.out.println(" 3. 最后运行集成测试，验证端到端交互");
Assertions.assertTrue(true, "测试分类说明完成");
}
@Test
@Order(3)
@DisplayName("测试执行顺序说明")
public void testExecutionOrderDescription() {
System.out.println("=== SIP代理测试执行顺序说明 ===");
System.out.println("推荐执行顺序：");
System.out.println();
System.out.println("第一阶段：基础功能测试");
System.out.println(" 1. ClientRegisterTest - 验证设备注册");
System.out.println(" 2. ServerRegisterTest - 验证注册管理");
System.out.println(" 3. ClientHeartbeatTest - 验证设备心跳");
System.out.println(" 4. ServerHeartbeatTest - 验证心跳监控");
System.out.println();
System.out.println("第二阶段：业务功能测试");
System.out.println(" 5. ClientCatalogTest - 验证目录查询");
System.out.println(" 6. ServerCatalogTest - 验证目录管理");
System.out.println(" 7. ClientControlTest - 验证控制响应");
System.out.println(" 8. ServerControlTest - 验证控制命令");
System.out.println(" 9. ClientInviteTest - 验证点播响应");
System.out.println(" 10. ServerInviteTest - 验证点播命令");
System.out.println();
System.out.println("第三阶段：集成测试");
System.out.println(" 11. SipProxyIntegrationTest - 端到端集成测试");
System.out.println(" 12. SipProxyBasicTest - 基础功能集成测试");
Assertions.assertTrue(true, "测试执行顺序说明完成");
}
@Test
@Order(4)
@DisplayName("测试配置验证")
public void testConfigurationValidation() {
System.out.println("=== SIP代理测试配置验证 ===");
// 验证配置参数
String serverId = "34020000002000000001";
String clientId = "34020000001320000001";
Assertions.assertNotNull(serverId, "服务端ID不能为空");
Assertions.assertNotNull(clientId, "客户端ID不能为空");
Assertions.assertNotEquals(serverId, clientId, "服务端ID和客户端ID不能相同");
System.out.println("服务端ID: " + serverId);
System.out.println("客户端ID: " + clientId);
System.out.println("配置验证通过");
}
@Test
@Order(5)
@DisplayName("测试完成总结")
public void testCompletionSummary() {
System.out.println("=== SIP代理测试完成总结 ===");
System.out.println("测试重构完成，已创建以下测试类：");
System.out.println();
System.out.println("客户端测试类（client包）：");
System.out.println(" ✓ ClientRegisterTest.java");
System.out.println(" ✓ ClientHeartbeatTest.java");
System.out.println(" ✓ ClientCatalogTest.java");
System.out.println(" - ClientControlTest.java (待创建)");
System.out.println(" - ClientInviteTest.java (待创建)");
System.out.println();
System.out.println("服务端测试类（server包）：");
System.out.println(" ✓ ServerRegisterTest.java");
System.out.println(" ✓ ServerHeartbeatTest.java");
System.out.println(" - ServerCatalogTest.java (待创建)");
System.out.println(" - ServerControlTest.java (待创建)");
System.out.println(" - ServerInviteTest.java (待创建)");
System.out.println();
System.out.println("文档和配置：");
System.out.println(" ✓ README.md - 测试结构说明");
System.out.println(" ✓ SipProxyTestRunner.java - 测试运行器");
System.out.println();
System.out.println("每个测试类都是独立的，可以单独运行");
System.out.println("测试类之间没有依赖关系，便于问题定位");
System.out.println("使用 @TestMethodOrder 确保测试方法按顺序执行");
Assertions.assertTrue(true, "测试重构完成");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/ServerCommandSenderAllTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/ServerCommandSenderAllTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gb28181.common.entity.response.DeviceInfo;
import io.github.lunasaw.gbproxy.server.transmit.cmd.ServerCommandSender;
import io.github.lunasaw.gbproxy.test.handler.TestClientMessageProcessorHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import java.util.Date;
import java.util.concurrent.TimeUnit;
/**
* MESSAGE 类型 的消息
* 服务端主动命令全量测试（只测ServerCommandSender定义的服务端主动命令）
*
* @author AI
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class ServerCommandSenderAllTest extends BasicSipCommonTest {
@Test
@Order(1)
@DisplayName("测试 deviceInfoQuery（设备信息查询）")
public void testDeviceInfoQuery() throws Exception {
TestClientMessageProcessorHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
String callId = ServerCommandSender.deviceInfoQuery(serverFromDevice, serverToDevice);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestClientMessageProcessorHandler.waitForDeviceInfo(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "客户端应收到设备信息查询请求");
// 可断言客户端响应内容
DeviceInfo deviceInfo = TestClientMessageProcessorHandler.getReceivedDeviceInfo();
Assertions.assertNotNull(deviceInfo, "设备信息响应不能为空");
}
@Test
@Order(2)
@DisplayName("测试 deviceStatusQuery（设备状态查询）")
public void testDeviceStatusQuery() throws Exception {
TestClientMessageProcessorHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
String callId = ServerCommandSender.deviceStatusQuery(serverFromDevice, serverToDevice);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestClientMessageProcessorHandler.waitForDeviceStatus(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "客户端应收到设备状态查询请求");
Assertions.assertNotNull(TestClientMessageProcessorHandler.getReceivedDeviceStatus(), "设备状态响应不能为空");
}
@Test
@Order(3)
@DisplayName("测试 deviceCatalogQuery（设备目录查询）")
public void testDeviceCatalogQuery() throws Exception {
TestClientMessageProcessorHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
String callId = ServerCommandSender.deviceCatalogQuery(serverFromDevice, serverToDevice);
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestClientMessageProcessorHandler.waitForCatalog(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "客户端应收到设备目录查询请求");
Assertions.assertNotNull(TestClientMessageProcessorHandler.getReceivedCatalog(), "设备目录响应不能为空");
}
@Test
@Order(4)
@DisplayName("测试 deviceRecordInfoQuery（录像信息查询）")
public void testDeviceRecordInfoQuery() throws Exception {
TestClientMessageProcessorHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
String callId = ServerCommandSender.deviceRecordInfoQuery(serverFromDevice, serverToDevice, new Date(), new Date());
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestClientMessageProcessorHandler.waitForDeviceRecord(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "客户端应收到录像信息查询请求");
Assertions.assertNotNull(TestClientMessageProcessorHandler.getReceivedDeviceRecord(), "录像响应不能为空");
}
@Test
@Order(5)
@DisplayName("测试 deviceMobilePositionQuery（移动位置查询）")
public void testDeviceMobilePositionQuery() throws Exception {
TestClientMessageProcessorHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
String callId = ServerCommandSender.deviceMobilePositionQuery(serverFromDevice, serverToDevice, "60");
Assertions.assertNotNull(callId, "callId不能为空");
boolean received = TestClientMessageProcessorHandler.waitForMobilePosition(5, TimeUnit.SECONDS);
Assertions.assertTrue(received, "客户端应收到移动位置查询请求");
Assertions.assertNotNull(TestClientMessageProcessorHandler.getReceivedMobilePosition(), "移动位置响应不能为空");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/InviteRequestProcessorTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/InviteRequestProcessorTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.test.handler.TestServerInviteRequestHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.Order;
import org.springframework.test.context.TestPropertySource;
/**
* INVITE请求处理器测试
* 演示如何使用新的测试架构进行端到端测试
*
* @author luna
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@Slf4j
public class InviteRequestProcessorTest extends BasicSipCommonTest {
@Test
@Order(1)
void testInvitePlayRequest() throws InterruptedException {
TestServerInviteRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
log.info("🧪 开始测试INVITE实时点播请求");
// 构造实时点播的SDP内容
String sdpContent = "v=0\r\n" +
"o=41010500002000000001 0 0 IN IP4 127.0.0.1\r\n" +
"s=Play\r\n" +
"c=IN IP4 127.0.0.1\r\n" +
"t=0 0\r\n" +
"m=video 6000 RTP/AVP 96\r\n" +
"a=rtpmap:96 PS/90000\r\n";
// 发送INVITE请求
String callId = SipSender.doInviteRequest(serverFromDevice, serverToDevice, sdpContent, "test-subject");
log.info("📤 发送INVITE实时点播请求: callId={}", callId);
// 等待测试钩子触发
boolean received = TestServerInviteRequestHandler.waitForInvitePlay(5, TimeUnit.SECONDS);
assertTrue(received, "应该收到INVITE实时点播请求");
// 验证测试钩子状态
assertTrue(TestServerInviteRequestHandler.hasReceivedInvitePlay(), "应该标记为已收到实时点播");
assertEquals(callId, TestServerInviteRequestHandler.getReceivedInvitePlayCallId(), "CallId应该匹配");
assertNotNull(TestServerInviteRequestHandler.getReceivedInvitePlaySdp(), "SDP内容不应该为空");
log.info("✅ INVITE实时点播请求测试通过");
}
@Test
@Order(2)
void testInvitePlayBackRequest() throws InterruptedException {
TestServerInviteRequestHandler.resetTestState();
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
log.info("🧪 开始测试INVITE回放点播请求");
// 构造回放点播的SDP内容
String sdpContent = "v=0\r\n" +
"o=41010500002000000001 0 0 IN IP4 127.0.0.1\r\n" +
"s=PlayBack\r\n" +
"c=IN IP4 127.0.0.1\r\n" +
"t=1704067200 1704153600\r\n" +
"m=video 6000 RTP/AVP 96\r\n" +
"a=rtpmap:96 PS/90000\r\n";
// 发送INVITE请求
String callId = SipSender.doInviteRequest(serverFromDevice, serverToDevice, sdpContent, "test-subject");
log.info("📤 发送INVITE回放点播请求: callId={}", callId);
// 等待测试钩子触发
boolean received = TestServerInviteRequestHandler.waitForInvitePlayBack(5, TimeUnit.SECONDS);
assertTrue(received, "应该收到INVITE回放点播请求");
// 验证测试钩子状态
assertTrue(TestServerInviteRequestHandler.hasReceivedInvitePlayBack(), "应该标记为已收到回放点播");
assertEquals(callId, TestServerInviteRequestHandler.getReceivedInvitePlayBackCallId(), "CallId应该匹配");
assertNotNull(TestServerInviteRequestHandler.getReceivedInvitePlayBackSdp(), "SDP内容不应该为空");
log.info("✅ INVITE回放点播请求测试通过");
}
@Test
@Order(3)
void testInviteRequestHandlerBusinessLogic() throws Exception {
TestServerInviteRequestHandler.resetTestState();
log.info("🧪 开始测试InviteRequestHandler业务逻辑");
// 创建测试用的SDP内容 - 按照GB28181协议标准
String testSdpContent = "v=0\r\n" +
"o=41010500002000000001 0 0 IN IP4 127.0.0.1\r\n" +
"s=Play\r\n" +
"c=IN IP4 127.0.0.1\r\n" +
"t=0 0\r\n" +
"m=video 6000 RTP/AVP 96\r\n" +
"a=rtpmap:96 PS/90000\r\n" +
"y=0123456789ABCDEF\r\n" + // GB28181特有的SSRC字段
"f=v/////a/1/8/1\r\n"; // GB28181特有的媒体格式字段
// 使用SipUtils.parseSdp创建SdpSessionDescription对象
io.github.lunasaw.sip.common.entity.SdpSessionDescription sessionDescription =
io.github.lunasaw.sip.common.utils.SipUtils.parseSdp(testSdpContent);
log.info("📋 创建的SDP会话描述: {}", sessionDescription);
TestServerInviteRequestHandler handler = new TestServerInviteRequestHandler();
// 测试inviteSession方法 - 验证会话处理逻辑
String callId = "test-call-id-123";
handler.inviteSession(callId, sessionDescription);
// 验证测试钩子状态 - 应该识别为实时点播
assertTrue(TestServerInviteRequestHandler.hasReceivedInvitePlay(), "应该识别为实时点播请求");
assertEquals(callId, TestServerInviteRequestHandler.getReceivedInvitePlayCallId(), "CallId应该匹配");
assertNotNull(TestServerInviteRequestHandler.getReceivedInvitePlaySdp(), "接收的SDP内容不应该为空");
// 测试getInviteResponse方法 - 验证响应生成逻辑
String userId = "41010500002000000001";
String response = handler.getInviteResponse(userId, sessionDescription);
// 验证响应内容包含必要的SDP字段
assertNotNull(response, "响应内容不应该为空");
assertTrue(response.contains("v=0"), "响应应该包含SDP版本");
assertTrue(response.contains("s=Play"), "响应应该包含会话名称");
assertTrue(response.contains("m=video"), "响应应该包含视频媒体描述");
assertTrue(response.contains("o=" + userId), "响应应该包含正确的用户ID");
assertTrue(response.contains("a=rtpmap:96 PS/90000"), "响应应该包含RTP映射");
log.info("📤 生成的响应SDP: {}", response);
// 测试回放点播场景
TestServerInviteRequestHandler.resetTestState();
String playbackSdpContent = "v=0\r\n" +
"o=41010500002000000001 0 0 IN IP4 127.0.0.1\r\n" +
"s=PlayBack\r\n" +
"c=IN IP4 127.0.0.1\r\n" +
"t=1704067200 1704153600\r\n" + // 指定回放时间范围
"m=video 6000 RTP/AVP 96\r\n" +
"a=rtpmap:96 PS/90000\r\n" +
"y=FEDCBA9876543210\r\n" + // 不同的SSRC
"f=v/////a/1/8/1\r\n";
io.github.lunasaw.sip.common.entity.SdpSessionDescription playbackSessionDescription =
io.github.lunasaw.sip.common.utils.SipUtils.parseSdp(playbackSdpContent);
String playbackCallId = "test-playback-call-id-456";
handler.inviteSession(playbackCallId, playbackSessionDescription);
// 验证回放点播钩子状态
assertTrue(TestServerInviteRequestHandler.hasReceivedInvitePlayBack(), "应该识别为回放点播请求");
assertEquals(playbackCallId, TestServerInviteRequestHandler.getReceivedInvitePlayBackCallId(), "回放CallId应该匹配");
assertNotNull(TestServerInviteRequestHandler.getReceivedInvitePlayBackSdp(), "回放SDP内容不应该为空");
// 验证GB28181特有字段解析
if (sessionDescription instanceof io.github.lunasaw.sip.common.entity.GbSessionDescription) {
io.github.lunasaw.sip.common.entity.GbSessionDescription gbSdp =
(io.github.lunasaw.sip.common.entity.GbSessionDescription) sessionDescription;
assertNotNull(gbSdp.getSsrc(), "SSRC字段应该被正确解析");
assertNotNull(gbSdp.getMediaDescription(), "媒体描述字段应该被正确解析");
log.info("🎯 GB28181字段解析成功: SSRC={}, MediaDescription={}", gbSdp.getSsrc(), gbSdp.getMediaDescription());
}
log.info("✅ InviteRequestHandler业务逻辑测试通过");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/BasicSipCommonTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/BasicSipCommonTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.gbproxy.test.config.TestDeviceSupplier;
import io.github.lunasaw.gbproxy.test.handler.TestServerMessageProcessorHandler;
import io.github.lunasaw.gbproxy.test.utils.TestSipRequestUtils;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.layer.SipLayer;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import javax.sip.SipListener;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* 基础SIP通用功能测试
* 测试SIP协议的基本功能和设备管理
*
* @author claude
* @date 2025/01/19
*/
@SpringBootTest(classes = Gb28181ApplicationTest.class,
webEnvironment = SpringBootTest.WebEnvironment.NONE)
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.main.allow-bean-definition-overriding=true",
"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
"logging.level.io.github.lunasaw.sip=DEBUG",
"logging.level.io.github.lunasaw.gbproxy=DEBUG"
})
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class BasicSipCommonTest {
@Autowired(required = false)
protected TestDeviceSupplier deviceSupplier;
@Autowired(required = false)
protected SipLayer sipLayer;
@Autowired(required = false)
protected SipListener sipListener;
@Autowired(required = false)
protected io.github.lunasaw.gbproxy.server.transmit.request.message.ServerMessageRequestProcessor serverMessageRequestProcessor;
@BeforeEach
public void setUp() {
if (sipLayer != null && sipListener != null && deviceSupplier != null) {
// Set up SIP listener
sipLayer.setSipListener(sipListener);
// Set up listening points for server (5060) and client (5061)
sipLayer.addListeningPoint("127.0.0.1", 5060);
sipLayer.addListeningPoint("127.0.0.1", 5061);
// Manually register MESSAGE processor if needed
if (sipListener instanceof io.github.lunasaw.sip.common.transmit.AbstractSipListener) {
io.github.lunasaw.sip.common.transmit.AbstractSipListener abstractListener =
(io.github.lunasaw.sip.common.transmit.AbstractSipListener) sipListener;
// Check if MESSAGE processor is already registered
if (abstractListener.getRequestProcessors("MESSAGE") == null && serverMessageRequestProcessor != null) {
System.out.println("🔧 手动注册MESSAGE处理器");
abstractListener.addRequestProcessor("MESSAGE", serverMessageRequestProcessor);
}
System.out.println("🔍 Registered processors: " + abstractListener.getProcessorStats());
System.out.println("🔍 MESSAGE processors: " + abstractListener.getRequestProcessors("MESSAGE"));
}
System.out.println("✓ SipLayer初始化完成 - 监听端口: 5060 (server), 5061 (client)");
}
}
@Test
@Order(1)
@DisplayName("测试Spring上下文加载")
public void testSpringContextLoads() {
Assertions.assertTrue(true, "Spring上下文应该能够加载");
System.out.println("✓ Spring上下文加载成功");
}
@Test
@Order(2)
@DisplayName("测试设备提供器注入")
public void testDeviceSupplierInjection() {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过设备提供器测试 - 未注入");
return;
}
Assertions.assertNotNull(deviceSupplier, "设备提供器应该被正确注入");
System.out.println("✓ 设备提供器注入成功: " + deviceSupplier.getClass().getSimpleName());
}
@Test
@Order(3)
@DisplayName("测试设备获取和转换功能")
public void testDeviceRetrieval() {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过设备获取测试 - 设备提供器未注入");
return;
}
try {
// 测试客户端设备转换
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice != null) {
Assertions.assertNotNull(clientFromDevice.getUserId(), "客户端From设备ID不能为空");
System.out.println("✓ 客户端From设备: " + clientFromDevice.getUserId() + "@" +
clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
}
if (clientToDevice != null) {
Assertions.assertNotNull(clientToDevice.getUserId(), "客户端To设备ID不能为空");
System.out.println("✓ 客户端To设备: " + clientToDevice.getUserId() + "@" +
clientToDevice.getIp() + ":" + clientToDevice.getPort());
}
// 测试服务端设备转换
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
if (serverFromDevice != null) {
Assertions.assertNotNull(serverFromDevice.getUserId(), "服务端From设备ID不能为空");
System.out.println("✓ 服务端From设备: " + serverFromDevice.getUserId() + "@" +
serverFromDevice.getIp() + ":" + serverFromDevice.getPort());
}
if (serverToDevice != null) {
Assertions.assertNotNull(serverToDevice.getUserId(), "服务端To设备ID不能为空");
System.out.println("✓ 服务端To设备: " + serverToDevice.getUserId() + "@" +
serverToDevice.getIp() + ":" + serverToDevice.getPort());
}
} catch (Exception e) {
System.err.println("✗ 设备获取测试失败: " + e.getMessage());
e.printStackTrace();
Assertions.fail("设备获取测试失败: " + e.getMessage());
}
}
@Test
@Order(4)
@DisplayName("测试SIP请求工具类")
public void testSipRequestUtils() {
try {
// 测试CallId生成
String callId1 = TestSipRequestUtils.getNewCallId();
String callId2 = TestSipRequestUtils.getNewCallId();
Assertions.assertNotNull(callId1, "CallId不能为空");
Assertions.assertNotNull(callId2, "CallId不能为空");
Assertions.assertNotEquals(callId1, callId2, "生成的CallId应该不同");
System.out.println("✓ SIP请求工具类测试通过");
System.out.println(" CallId1: " + callId1);
System.out.println(" CallId2: " + callId2);
} catch (Exception e) {
System.err.println("✗ SIP请求工具类测试失败: " + e.getMessage());
e.printStackTrace();
Assertions.fail("SIP请求工具类测试失败: " + e.getMessage());
}
}
@Test
@Order(5)
@DisplayName("测试SIP REGISTER请求创建")
public void testCreateRegisterRequest() {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过SIP REGISTER请求测试 - 设备提供器未注入");
return;
}
try {
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过SIP REGISTER请求测试 - 设备未获取");
return;
}
// 直接使用SipSender发送REGISTER请求，避免策略问题
String resultCallId = io.github.lunasaw.sip.common.transmit.SipSender.doRegisterRequest(clientFromDevice, clientToDevice, 3600);
Assertions.assertNotNull(resultCallId, "REGISTER请求应该被成功创建");
System.out.println("✓ REGISTER请求创建成功");
System.out.println(" CallId: " + resultCallId);
System.out.println(" From: " + clientFromDevice.getUserId());
System.out.println(" To: " + clientToDevice.getUserId());
} catch (Exception e) {
System.err.println("✗ SIP REGISTER请求创建失败: " + e.getMessage());
e.printStackTrace();
Assertions.fail("SIP REGISTER请求创建失败: " + e.getMessage());
}
}
@Test
@Order(6)
@DisplayName("测试SIP MESSAGE请求创建")
public void testCreateMessageRequest() {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过SIP MESSAGE请求测试 - 设备提供器未注入");
return;
}
try {
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过SIP MESSAGE请求测试 - 设备未获取");
return;
}
String callId = TestSipRequestUtils.getNewCallId();
String xmlContent = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<Control>\n" +
" <CmdType>Keepalive</CmdType>\n" +
" <SN>1</SN>\n" +
" <DeviceID>" + clientFromDevice.getUserId() + "</DeviceID>\n" +
"</Control>";
String resultCallId = ClientCommandSender.sendCommand("MESSAGE", clientFromDevice, clientToDevice, xmlContent);
Assertions.assertNotNull(resultCallId, "MESSAGE请求应该被成功创建");
System.out.println("✓ MESSAGE请求创建成功");
System.out.println(" CallId: " + resultCallId);
System.out.println(" Content: " + xmlContent);
} catch (Exception e) {
System.err.println("✗ SIP MESSAGE请求创建失败: " + e.getMessage());
e.printStackTrace();
Assertions.fail("SIP MESSAGE请求创建失败: " + e.getMessage());
}
}
@Test
@Order(7)
@DisplayName("测试SIP MESSAGE请求发送和服务端接收")
public void testSendMessageRequest() {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过SIP MESSAGE请求发送测试 - 设备提供器未注入");
return;
}
try {
// 重置测试Handler状态
TestServerMessageProcessorHandler.resetTestState();
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice == null || clientToDevice == null) {
System.out.println("⚠ 跳过SIP MESSAGE请求发送测试 - 设备未获取");
return;
}
System.out.println("📤 准备发送MESSAGE请求");
System.out.println(" 发送方: " + clientFromDevice.getUserId() + "@" +
clientFromDevice.getIp() + ":" + clientFromDevice.getPort());
System.out.println(" 接收方: " + clientToDevice.getUserId() + "@" +
clientToDevice.getIp() + ":" + clientToDevice.getPort());
System.out.println(" 消息内容: Keepalive命令");
// 发送MESSAGE请求
String callId = ClientCommandSender.sendKeepaliveCommand(clientFromDevice, clientToDevice, "onLine");
Assertions.assertNotNull(callId, "MESSAGE请求发送应该返回callId");
Assertions.assertFalse(callId.isEmpty(), "CallId不能为空");
System.out.println("✅ MESSAGE请求发送成功，CallId: " + callId);
// 等待服务端接收心跳消息，最多等待5秒
System.out.println("⏳ 等待服务端接收和处理心跳消息...");
boolean received = TestServerMessageProcessorHandler.waitForKeepalive(5, TimeUnit.SECONDS);
// 验证服务端是否接收到心跳消息
Assertions.assertTrue(received, "服务端应该在5秒内接收到心跳消息");
Assertions.assertTrue(TestServerMessageProcessorHandler.hasReceivedKeepalive(),
"服务端应该成功接收心跳消息");
// 验证接收到的心跳内容
var receivedKeepalive = TestServerMessageProcessorHandler.getReceivedKeepalive();
Assertions.assertNotNull(receivedKeepalive, "接收到的心跳内容不能为空");
Assertions.assertNotNull(receivedKeepalive.getDeviceId(), "心跳设备ID不能为空");
Assertions.assertEquals(clientFromDevice.getUserId(), receivedKeepalive.getDeviceId(),
"心跳设备ID应该与发送方设备ID一致");
System.out.println("✅ 服务端成功接收MESSAGE请求并处理心跳");
System.out.println("✅ 心跳内容验证通过: 设备ID=" + receivedKeepalive.getDeviceId());
System.out.println("✅ CallId验证通过: " + callId);
System.out.println("🎉 MESSAGE请求端到端验证完全成功！");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println("❌ SIP MESSAGE请求发送测试被中断: " + e.getMessage());
Assertions.fail("SIP MESSAGE请求发送测试被中断: " + e.getMessage());
} catch (Exception e) {
System.err.println("❌ SIP MESSAGE请求发送测试失败: " + e.getMessage());
e.printStackTrace();
Assertions.fail("SIP MESSAGE请求发送测试失败: " + e.getMessage());
}
}
@Test
@Order(8)
@DisplayName("测试设备配置验证")
public void testDeviceConfiguration() {
if (deviceSupplier == null) {
System.out.println("⚠ 跳过设备配置验证测试 - 设备提供器未注入");
return;
}
try {
// 验证客户端设备配置
FromDevice clientFromDevice = deviceSupplier.getClientFromDevice();
ToDevice clientToDevice = deviceSupplier.getClientToDevice();
if (clientFromDevice != null) {
Assertions.assertNotNull(clientFromDevice.getUserId(), "客户端From设备ID不能为空");
Assertions.assertNotNull(clientFromDevice.getIp(), "客户端From设备IP不能为空");
Assertions.assertTrue(clientFromDevice.getPort() > 0, "客户端From设备端口必须大于0");
System.out.println("✓ 客户端From设备配置验证通过");
}
if (clientToDevice != null) {
Assertions.assertNotNull(clientToDevice.getUserId(), "客户端To设备ID不能为空");
Assertions.assertNotNull(clientToDevice.getIp(), "客户端To设备IP不能为空");
Assertions.assertTrue(clientToDevice.getPort() > 0, "客户端To设备端口必须大于0");
System.out.println("✓ 客户端To设备配置验证通过");
}
// 验证服务端设备配置
FromDevice serverFromDevice = deviceSupplier.getServerFromDevice();
ToDevice serverToDevice = deviceSupplier.getServerToDevice();
if (serverFromDevice != null) {
Assertions.assertNotNull(serverFromDevice.getUserId(), "服务端From设备ID不能为空");
Assertions.assertNotNull(serverFromDevice.getIp(), "服务端From设备IP不能为空");
Assertions.assertTrue(serverFromDevice.getPort() > 0, "服务端From设备端口必须大于0");
System.out.println("✓ 服务端From设备配置验证通过");
}
if (serverToDevice != null) {
Assertions.assertNotNull(serverToDevice.getUserId(), "服务端To设备ID不能为空");
Assertions.assertNotNull(serverToDevice.getIp(), "服务端To设备IP不能为空");
Assertions.assertTrue(serverToDevice.getPort() > 0, "服务端To设备端口必须大于0");
System.out.println("✓ 服务端To设备配置验证通过");
}
} catch (Exception e) {
System.err.println("✗ 设备配置验证失败: " + e.getMessage());
e.printStackTrace();
Assertions.fail("设备配置验证失败: " + e.getMessage());
}
}
@AfterEach
public void tearDown() {
System.out.println("--- 测试用例完成 ---\n");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/config/TestDeviceSupplierTest.java | gb28181-test/src/test/java/io/github/lunasaw/gbproxy/test/config/TestDeviceSupplierTest.java | package io.github.lunasaw.gbproxy.test.config;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
/**
* TestDeviceSupplier测试类
* 验证重构后的设备提供器功能
*
* @author luna
* @date 2025/01/23
*/
@SpringBootTest(classes = TestDeviceSupplier.class)
@DisplayName("TestDeviceSupplier测试")
public class TestDeviceSupplierTest {
@Autowired
private TestDeviceSupplier testDeviceSupplier;
@BeforeEach
public void setUp() {
// 确保设备已初始化
assertNotNull(testDeviceSupplier, "TestDeviceSupplier应该被正确注入");
}
@Test
@DisplayName("测试设备初始化")
public void testDeviceInitialization() {
// 验证所有设备都能获取到
Device device1 = testDeviceSupplier.getDevice("33010602011187000001");
Device device2 = testDeviceSupplier.getDevice("41010500002000000001");
assertNotNull(device1, "设备1应该存在");
assertNotNull(device2, "设备2应该存在");
System.out.println("设备1: " + device1.getUserId() + "@" + device1.getIp() + ":" + device1.getPort());
System.out.println("设备2: " + device2.getUserId() + "@" + device2.getIp() + ":" + device2.getPort());
}
@Test
@DisplayName("测试客户端From设备转换")
public void testClientFromDeviceConversion() {
FromDevice clientFrom = testDeviceSupplier.getClientFromDevice();
assertNotNull(clientFrom, "客户端From设备不能为空");
assertEquals("33010602011187000001", clientFrom.getUserId(), "用户ID应该正确");
assertEquals("127.0.0.1", clientFrom.getIp(), "IP地址应该正确");
assertEquals(5061, clientFrom.getPort(), "端口应该正确");
assertNotNull(clientFrom.getFromTag(), "FromTag应该存在");
assertNotNull(clientFrom.getAgent(), "Agent应该存在");
System.out.println("客户端From设备: " + clientFrom.getUserId() + "@" + clientFrom.getIp() + ":" + clientFrom.getPort());
System.out.println("FromTag: " + clientFrom.getFromTag());
System.out.println("Agent: " + clientFrom.getAgent());
}
@Test
@DisplayName("测试客户端To设备转换")
public void testClientToDeviceConversion() {
ToDevice clientTo = testDeviceSupplier.getClientToDevice();
assertNotNull(clientTo, "客户端To设备不能为空");
assertEquals("41010500002000000001", clientTo.getUserId(), "用户ID应该正确");
assertEquals("127.0.0.1", clientTo.getIp(), "IP地址应该正确");
assertEquals(5060, clientTo.getPort(), "端口应该正确");
assertEquals("bajiuwulian1006", clientTo.getPassword(), "密码应该正确");
assertEquals("4101050000", clientTo.getRealm(), "Realm应该正确");
System.out.println("客户端To设备: " + clientTo.getUserId() + "@" + clientTo.getIp() + ":" + clientTo.getPort());
System.out.println("Password: " + clientTo.getPassword());
System.out.println("Realm: " + clientTo.getRealm());
}
@Test
@DisplayName("测试服务端From设备转换")
public void testServerFromDeviceConversion() {
FromDevice serverFrom = testDeviceSupplier.getServerFromDevice();
assertNotNull(serverFrom, "服务端From设备不能为空");
assertEquals("41010500002000000001", serverFrom.getUserId(), "用户ID应该正确");
assertEquals("127.0.0.1", serverFrom.getIp(), "IP地址应该正确");
assertEquals(5060, serverFrom.getPort(), "端口应该正确");
assertEquals("bajiuwulian1006", serverFrom.getPassword(), "密码应该正确");
assertEquals("4101050000", serverFrom.getRealm(), "Realm应该正确");
assertNotNull(serverFrom.getFromTag(), "FromTag应该存在");
System.out.println("服务端From设备: " + serverFrom.getUserId() + "@" + serverFrom.getIp() + ":" + serverFrom.getPort());
System.out.println("Password: " + serverFrom.getPassword());
System.out.println("Realm: " + serverFrom.getRealm());
System.out.println("FromTag: " + serverFrom.getFromTag());
}
@Test
@DisplayName("测试服务端To设备转换")
public void testServerToDeviceConversion() {
ToDevice serverTo = testDeviceSupplier.getServerToDevice();
assertNotNull(serverTo, "服务端To设备不能为空");
assertEquals("33010602011187000001", serverTo.getUserId(), "用户ID应该正确");
assertEquals("127.0.0.1", serverTo.getIp(), "IP地址应该正确");
assertEquals(5061, serverTo.getPort(), "端口应该正确");
System.out.println("服务端To设备: " + serverTo.getUserId() + "@" + serverTo.getIp() + ":" + serverTo.getPort());
}
@Test
@DisplayName("测试设备类型转换")
public void testDeviceTypeConversion() {
// 测试从Device转换为FromDevice
Device device = testDeviceSupplier.getDevice("33010602011187000001");
assertNotNull(device, "设备应该存在");
FromDevice fromDevice = testDeviceSupplier.getClientFromDevice();
assertNotNull(fromDevice, "FromDevice转换应该成功");
assertEquals(device.getUserId(), fromDevice.getUserId(), "用户ID应该一致");
assertEquals(device.getIp(), fromDevice.getIp(), "IP地址应该一致");
assertEquals(device.getPort(), fromDevice.getPort(), "端口应该一致");
// 测试从Device转换为ToDevice
Device device2 = testDeviceSupplier.getDevice("41010500002000000001");
assertNotNull(device2, "设备2应该存在");
ToDevice toDevice = testDeviceSupplier.getClientToDevice();
assertNotNull(toDevice, "ToDevice转换应该成功");
assertEquals(device2.getUserId(), toDevice.getUserId(), "用户ID应该一致");
assertEquals(device2.getIp(), toDevice.getIp(), "IP地址应该一致");
assertEquals(device2.getPort(), toDevice.getPort(), "端口应该一致");
}
@Test
@DisplayName("测试设备添加和更新")
public void testDeviceAddAndUpdate() {
// 添加新设备
FromDevice newDevice = FromDevice.getInstance("test-device-001", "192.168.1.100", 8080);
testDeviceSupplier.addOrUpdateDevice(newDevice);
// 验证设备已添加
Device retrievedDevice = testDeviceSupplier.getDevice("test-device-001");
assertNotNull(retrievedDevice, "新添加的设备应该存在");
assertEquals("test-device-001", retrievedDevice.getUserId(), "用户ID应该正确");
// 更新设备
ToDevice updatedDevice = ToDevice.getInstance("test-device-001", "192.168.1.200", 8081);
updatedDevice.setPassword("new-password");
testDeviceSupplier.addOrUpdateDevice(updatedDevice);
// 验证设备已更新
Device retrievedUpdatedDevice = testDeviceSupplier.getDevice("test-device-001");
assertNotNull(retrievedUpdatedDevice, "更新后的设备应该存在");
assertEquals("192.168.1.200", retrievedUpdatedDevice.getIp(), "IP地址应该已更新");
assertEquals(8081, retrievedUpdatedDevice.getPort(), "端口应该已更新");
}
@Test
@DisplayName("测试设备类型统计")
public void testDeviceTypeStatistics() {
// 获取所有FromDevice
List<FromDevice> fromDevices = testDeviceSupplier.getFromDevices();
assertNotNull(fromDevices, "FromDevice列表不能为空");
assertTrue(fromDevices.size() >= 1, "应该至少有1个FromDevice");
// 获取所有ToDevice
List<ToDevice> toDevices = testDeviceSupplier.getToDevices();
assertNotNull(toDevices, "ToDevice列表不能为空");
assertTrue(toDevices.size() >= 1, "应该至少有1个ToDevice");
System.out.println("FromDevice数量: " + fromDevices.size());
System.out.println("ToDevice数量: " + toDevices.size());
// 验证设备类型
fromDevices.forEach(device -> {
assertTrue(device instanceof FromDevice, "应该是FromDevice类型");
System.out.println("FromDevice: " + device.getUserId());
});
toDevices.forEach(device -> {
assertTrue(device instanceof ToDevice, "应该是ToDevice类型");
System.out.println("ToDevice: " + device.getUserId());
});
}
@Test
@DisplayName("测试设备提供器名称")
public void testDeviceSupplierName() {
String name = testDeviceSupplier.getName();
assertEquals("TestDeviceSupplier", name, "设备提供器名称应该正确");
System.out.println("设备提供器名称: " + name);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/SimpleTestVerifier.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/SimpleTestVerifier.java | package io.github.lunasaw.gbproxy.test;
import java.util.Random;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
* 简单测试验证器
* 用于验证测试模块的核心功能，不依赖外部组件
*/
public class SimpleTestVerifier {
private final Random random = new Random();
private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) {
SimpleTestVerifier verifier = new SimpleTestVerifier();
verifier.runVerificationTests();
}
public void runVerificationTests() {
System.out.println("=== GB28181 测试模块独立验证 ===");
System.out.println("开始时间: " + LocalDateTime.now().format(formatter));
System.out.println();
// 测试数据生成功能
testDataGeneration();
// 测试SIP协议相关功能
testSipFunctions();
// 测试GB28181设备ID生成
testDeviceIdGeneration();
// 测试XML消息生成
testXmlGeneration();
System.out.println();
System.out.println("=== 验证完成 ===");
System.out.println("结束时间: " + LocalDateTime.now().format(formatter));
System.out.println("测试模块核心功能验证通过，可以独立运行！");
}
private void testDataGeneration() {
System.out.println("[测试] 数据生成功能");
// 生成随机设备ID
String deviceId = generateDeviceId("44050100");
System.out.println(" 生成设备ID: " + deviceId);
// 生成测试用户名
String username = generateTestUsername();
System.out.println(" 生成用户名: " + username);
// 生成测试密码
String password = generateTestPassword();
System.out.println(" 生成密码: " + password);
// 生成测试IP
String ip = generateTestIpAddress();
System.out.println(" 生成IP地址: " + ip);
// 生成测试端口
int port = generateTestPort();
System.out.println(" 生成端口: " + port);
System.out.println(" ✓ 数据生成功能正常");
System.out.println();
}
private void testSipFunctions() {
System.out.println("[测试] SIP协议功能");
String callId = generateCallId();
System.out.println(" 生成Call-ID: " + callId);
String viaBranch = generateViaBranch();
System.out.println(" 生成Via分支: " + viaBranch);
String tag = generateTag();
System.out.println(" 生成Tag: " + tag);
System.out.println(" ✓ SIP协议功能正常");
System.out.println();
}
private void testDeviceIdGeneration() {
System.out.println("[测试] GB28181设备ID生成");
for (int i = 0; i < 3; i++) {
String deviceId = generateDeviceId("44050100");
System.out.println(" 设备ID " + (i + 1) + ": " + deviceId);
// 验证设备ID格式
if (deviceId.length() == 20 && deviceId.startsWith("44050100")) {
System.out.println(" ✓ 格式正确");
} else {
System.out.println(" ✗ 格式错误");
}
}
System.out.println(" ✓ 设备ID生成功能正常");
System.out.println();
}
private void testXmlGeneration() {
System.out.println("[测试] XML消息生成");
String deviceId = "34020000001320000001";
String deviceInfoXml = generateDeviceInfoXml(deviceId);
System.out.println(" 设备信息XML (部分): " + deviceInfoXml.substring(0, Math.min(100, deviceInfoXml.length())) + "...");
String deviceStatusXml = generateDeviceStatusXml(deviceId);
System.out.println(" 设备状态XML (部分): " + deviceStatusXml.substring(0, Math.min(100, deviceStatusXml.length())) + "...");
String catalogXml = generateCatalogXml(deviceId, 2);
System.out.println(" 目录查询XML (部分): " + catalogXml.substring(0, Math.min(100, catalogXml.length())) + "...");
System.out.println(" ✓ XML消息生成功能正常");
System.out.println();
}
// 生成设备ID的简化版本
private String generateDeviceId(String prefix) {
if (prefix == null) {
prefix = "44050100";
}
if (prefix.length() > 8) {
prefix = prefix.substring(0, 8);
} else if (prefix.length() < 8) {
prefix = String.format("%-8s", prefix).replace(' ', '0');
}
StringBuilder sb = new StringBuilder(prefix);
for (int i = 0; i < 12; i++) {
sb.append(random.nextInt(10));
}
return sb.toString();
}
private String generateCallId() {
return "call-" + System.currentTimeMillis() + "-" + random.nextInt(10000);
}
private String generateViaBranch() {
return "z9hG4bK-" + System.currentTimeMillis() + "-" + random.nextInt(10000);
}
private String generateTag() {
return "tag-" + System.currentTimeMillis() + "-" + random.nextInt(10000);
}
private String generateTestIpAddress() {
return "192.168." + random.nextInt(256) + "." + (random.nextInt(254) + 1);
}
private int generateTestPort() {
return 5000 + random.nextInt(55000);
}
private String generateTestUsername() {
String[] prefixes = {"test", "user", "device", "client"};
String prefix = prefixes[random.nextInt(prefixes.length)];
return prefix + "_" + random.nextInt(1000);
}
private String generateTestPassword() {
String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
StringBuilder password = new StringBuilder();
int length = 8 + random.nextInt(8);
for (int i = 0; i < length; i++) {
password.append(chars.charAt(random.nextInt(chars.length())));
}
return password.toString();
}
private String generateDeviceInfoXml(String deviceId) {
return String.format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<Response>\n" +
" <CmdType>DeviceInfo</CmdType>\n" +
" <SN>%d</SN>\n" +
" <DeviceID>%s</DeviceID>\n" +
" <DeviceName>%s</DeviceName>\n" +
" <Manufacturer>%s</Manufacturer>\n" +
" <Model>%s</Model>\n" +
" <Firmware>%s</Firmware>\n" +
" <Channel>%d</Channel>\n" +
" <Result>OK</Result>\n" +
"</Response>",
System.currentTimeMillis() % 100000,
deviceId,
"测试设备-" + deviceId.substring(deviceId.length() - 4),
"测试厂商",
"TestModel-" + random.nextInt(100),
"V" + random.nextInt(5) + "." + random.nextInt(10) + "." + random.nextInt(10),
random.nextInt(32) + 1
);
}
private String generateDeviceStatusXml(String deviceId) {
return String.format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<Response>\n" +
" <CmdType>DeviceStatus</CmdType>\n" +
" <SN>%d</SN>\n" +
" <DeviceID>%s</DeviceID>\n" +
" <Result>OK</Result>\n" +
" <Online>%s</Online>\n" +
" <Status>%s</Status>\n" +
"</Response>",
System.currentTimeMillis() % 100000,
deviceId,
random.nextBoolean() ? "ONLINE" : "OFFLINE",
random.nextBoolean() ? "OK" : "ERROR"
);
}
private String generateCatalogXml(String deviceId, int channelCount) {
StringBuilder xml = new StringBuilder();
xml.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
xml.append("<Response>\n");
xml.append(" <CmdType>Catalog</CmdType>\n");
xml.append(" <SN>").append(System.currentTimeMillis() % 100000).append("</SN>\n");
xml.append(" <DeviceID>").append(deviceId).append("</DeviceID>\n");
xml.append(" <SumNum>").append(channelCount).append("</SumNum>\n");
xml.append(" <DeviceList Num=\"").append(channelCount).append("\">\n");
for (int i = 1; i <= channelCount; i++) {
String channelId = deviceId.substring(0, 10) + String.format("%010d", i);
xml.append(" <Item>\n");
xml.append(" <DeviceID>").append(channelId).append("</DeviceID>\n");
xml.append(" <Name>通道-").append(i).append("</Name>\n");
xml.append(" <Manufacturer>测试厂商</Manufacturer>\n");
xml.append(" <Model>TestChannel</Model>\n");
xml.append(" <Owner>Admin</Owner>\n");
xml.append(" <CivilCode>").append(deviceId.substring(0, 6)).append("</CivilCode>\n");
xml.append(" <Address>测试地址-").append(i).append("</Address>\n");
xml.append(" <Parental>1</Parental>\n");
xml.append(" <ParentID>").append(deviceId).append("</ParentID>\n");
xml.append(" <SafetyWay>0</SafetyWay>\n");
xml.append(" <RegisterWay>1</RegisterWay>\n");
xml.append(" <Secrecy>0</Secrecy>\n");
xml.append(" <Status>ON</Status>\n");
xml.append(" </Item>\n");
}
xml.append(" </DeviceList>\n");
xml.append("</Response>\n");
return xml.toString();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/Gb28181ApplicationTest.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/Gb28181ApplicationTest.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.test.config.TestConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
/**
* GB28181测试应用主类
* 用于单元测试和集成测试
*
* @author luna
* @date 2023/10/11
*/
@SpringBootApplication
@ComponentScan(basePackages = {
"io.github.lunasaw.sip.common",
"io.github.lunasaw.gbproxy"
})
@Import(TestConfiguration.class)
public class Gb28181ApplicationTest {
public static void main(String[] args) {
try {
SpringApplication.run(Gb28181ApplicationTest.class, args);
} catch (Exception e) {
System.err.println("应用启动失败: " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/TestFrameworkVerifyApplication.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/TestFrameworkVerifyApplication.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.test.config.TestSuiteConfig;
import io.github.lunasaw.gbproxy.test.runner.TestMetricsCollector;
import io.github.lunasaw.gbproxy.test.runner.TestReportGenerator;
import io.github.lunasaw.gbproxy.test.util.TestDataGenerator;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* GB28181测试模块验证应用
* 验证测试框架和工具类是否可以正常工作
*/
@Slf4j
@SpringBootApplication
public class TestFrameworkVerifyApplication implements CommandLineRunner {
@Autowired
private TestSuiteConfig testSuiteConfig;
@Autowired
private TestMetricsCollector metricsCollector;
@Autowired
private TestReportGenerator reportGenerator;
@Autowired
private TestDataGenerator dataGenerator;
public static void main(String[] args) {
log.info("========================================");
log.info(" GB28181测试框架验证启动");
log.info("========================================");
SpringApplication app = new SpringApplication(TestFrameworkVerifyApplication.class);
app.run(args);
}
@Override
public void run(String... args) throws Exception {
log.info("开始验证GB28181测试框架...");
// 验证配置加载
verifyConfiguration();
// 验证测试工具
verifyTestTools();
// 验证数据生成器
verifyDataGenerator();
// 验证指标收集器
verifyMetricsCollector();
// 验证报告生成器
verifyReportGenerator();
log.info("========================================");
log.info(" GB28181测试框架验证完成");
log.info("========================================");
log.info("✓ 所有测试框架组件工作正常");
log.info("✓ 测试模块可以独立运行");
log.info("✓ 配置文件加载正确");
log.info("✓ 工具类功能完整");
log.info("========================================");
}
private void verifyConfiguration() {
log.info(">>> 验证配置加载...");
log.info("测试模式: {}", testSuiteConfig.getMode());
log.info("测试套件: {}", testSuiteConfig.getSuite());
log.info("并发执行: {}", testSuiteConfig.isConcurrent());
log.info("生成报告: {}", testSuiteConfig.isReport());
log.info("输出目录: {}", testSuiteConfig.getOutputDir());
log.info("✓ 配置加载验证完成");
}
private void verifyTestTools() {
log.info(">>> 验证测试工具...");
// 测试基础工具是否可用
if (testSuiteConfig != null) {
log.info("✓ TestSuiteConfig 工具正常");
}
if (metricsCollector != null) {
log.info("✓ TestMetricsCollector 工具正常");
}
if (reportGenerator != null) {
log.info("✓ TestReportGenerator 工具正常");
}
if (dataGenerator != null) {
log.info("✓ TestDataGenerator 工具正常");
}
log.info("✓ 测试工具验证完成");
}
private void verifyDataGenerator() {
log.info(">>> 验证数据生成器...");
try {
// 生成测试设备ID
String deviceId = dataGenerator.generateDeviceId("44050100");
log.info("生成设备ID: {}", deviceId);
// 生成Call-ID
String callId = dataGenerator.generateCallId();
log.info("生成Call-ID: {}", callId);
// 生成XML消息
String deviceInfoXml = dataGenerator.generateDeviceInfoXml(deviceId);
log.info("生成设备信息XML: {}字符", deviceInfoXml.length());
String deviceStatusXml = dataGenerator.generateDeviceStatusXml(deviceId);
log.info("生成设备状态XML: {}字符", deviceStatusXml.length());
log.info("✓ 数据生成器验证完成");
} catch (Exception e) {
log.error("✗ 数据生成器验证失败", e);
throw new RuntimeException("数据生成器验证失败", e);
}
}
private void verifyMetricsCollector() {
log.info(">>> 验证指标收集器...");
try {
String sessionId = "verify-session-" + System.currentTimeMillis();
// 开始收集
metricsCollector.startCollection(sessionId);
// 记录一些测试指标
metricsCollector.recordTestStart("验证测试");
Thread.sleep(100);
metricsCollector.recordTestSuccess("验证测试");
metricsCollector.recordSipRequestSent("REGISTER");
metricsCollector.recordSipResponseReceived(200);
metricsCollector.recordGb28181Message("register");
// 停止收集
metricsCollector.stopCollection();
// 验证指标是否记录
long testCount = metricsCollector.getCounter("test.total");
long successCount = metricsCollector.getCounter("test.success");
log.info("记录的测试数量: {}", testCount);
log.info("记录的成功数量: {}", successCount);
log.info("✓ 指标收集器验证完成");
} catch (Exception e) {
log.error("✗ 指标收集器验证失败", e);
throw new RuntimeException("指标收集器验证失败", e);
}
}
private void verifyReportGenerator() {
log.info(">>> 验证报告生成器...");
try {
// 初始化输出目录
reportGenerator.initializeOutputDirectory();
// 添加一些测试结果
reportGenerator.addTestResult("验证测试1", "框架验证", true, 100, "测试通过", null);
reportGenerator.addTestResult("验证测试2", "框架验证", true, 150, "测试通过", null);
String sessionId = "verify-session-" + System.currentTimeMillis();
// 生成报告
reportGenerator.generateReport(sessionId);
log.info("✓ 报告生成器验证完成");
} catch (Exception e) {
log.error("✗ 报告生成器验证失败", e);
throw new RuntimeException("报告生成器验证失败", e);
}
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/SimpleTestApplication.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/SimpleTestApplication.java | package io.github.lunasaw.gbproxy.test;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 简化的测试应用启动类
* 用于验证测试模块可以独立运行
*/
@Slf4j
@SpringBootApplication
public class SimpleTestApplication {
public static void main(String[] args) {
log.info("========================================");
log.info(" GB28181测试模块启动验证");
log.info("========================================");
try {
SpringApplication app = new SpringApplication(SimpleTestApplication.class);
app.run(args);
log.info("✓ GB28181测试模块启动成功！");
log.info("✓ 所有配置和依赖加载正常");
log.info("✓ 测试框架初始化完成");
} catch (Exception e) {
log.error("✗ GB28181测试模块启动失败", e);
System.exit(1);
}
log.info("========================================");
log.info(" 测试模块独立运行验证完成");
log.info("========================================");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/Gb28181TestApplication.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/Gb28181TestApplication.java | package io.github.lunasaw.gbproxy.test;
import io.github.lunasaw.gbproxy.test.runner.AutoTestRunner;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
/**
* GB28181测试应用主程序
* 可独立运行的完整测试套件
* <p>
* 启动方式：
* 1. IDE运行：直接运行main方法
* 2. Maven运行：mvn spring-boot:run -pl gb28181-test
* 3. JAR运行：java -jar gb28181-test-1.2.5.jar
* <p>
* 参数说明：
* --test.mode=auto|manual 测试模式：自动化/手动
* --test.suite=all|server|client 测试套件：全部/服务端/客户端
* --test.concurrent=true|false 是否并发测试
* --test.report=true|false 是否生成测试报告
*/
@Slf4j
@SpringBootApplication
@ComponentScan(basePackages = {
"io.github.lunasaw.gbproxy.test",
"io.github.lunasaw.gbproxy.server",
"io.github.lunasaw.gbproxy.client",
"io.github.lunasaw.sip.common"
})
public class Gb28181TestApplication implements CommandLineRunner {
@Autowired
private AutoTestRunner autoTestRunner;
public static void main(String[] args) {
log.info("========================================");
log.info(" GB28181测试套件启动中...");
log.info("========================================");
SpringApplication app = new SpringApplication(Gb28181TestApplication.class);
app.run(args);
}
@Override
public void run(String... args) throws Exception {
log.info("GB28181测试应用已启动，开始执行测试套件...");
try {
// 执行自动化测试
// autoTestRunner.runTestSuite();
} catch (Exception e) {
log.error("测试执行过程中发生异常", e);
System.exit(1);
}
log.info("========================================");
log.info(" GB28181测试套件执行完成");
log.info("========================================");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/util/TestAssertions.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/util/TestAssertions.java | package io.github.lunasaw.gbproxy.test.util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
/**
* 自定义测试断言工具类
* 提供GB28181测试特有的断言方法
*/
@Slf4j
@Component
public class TestAssertions {
/**
* 断言SIP响应状态码
*/
public static void assertSipResponseCode(int actualCode, int expectedCode, String message) {
if (actualCode != expectedCode) {
throw new AssertionError(String.format("%s - 期望状态码: %d, 实际状态码: %d",
message, expectedCode, actualCode));
}
}
/**
* 断言SIP响应状态码在指定范围内
*/
public static void assertSipResponseCodeInRange(int actualCode, int minCode, int maxCode, String message) {
if (actualCode < minCode || actualCode > maxCode) {
throw new AssertionError(String.format("%s - 期望状态码范围: %d-%d, 实际状态码: %d",
message, minCode, maxCode, actualCode));
}
}
/**
* 断言SIP消息头部存在
*/
public static void assertSipHeaderExists(String headerValue, String headerName, String message) {
if (headerValue == null || headerValue.trim().isEmpty()) {
throw new AssertionError(String.format("%s - SIP头部 '%s' 不存在或为空", message, headerName));
}
}
/**
* 断言SIP消息头部包含指定值
*/
public static void assertSipHeaderContains(String headerValue, String expectedContent,
String headerName, String message) {
assertSipHeaderExists(headerValue, headerName, message);
if (!headerValue.contains(expectedContent)) {
throw new AssertionError(String.format("%s - SIP头部 '%s' 不包含期望内容 '%s', 实际值: %s",
message, headerName, expectedContent, headerValue));
}
}
/**
* 断言GB28181设备ID格式正确
*/
public static void assertValidGb28181DeviceId(String deviceId, String message) {
if (deviceId == null) {
throw new AssertionError(message + " - 设备ID不能为空");
}
if (deviceId.length() != 20) {
throw new AssertionError(String.format("%s - 设备ID长度应为20位, 实际长度: %d",
message, deviceId.length()));
}
if (!deviceId.matches("\\d{20}")) {
throw new AssertionError(String.format("%s - 设备ID应为20位数字, 实际值: %s",
message, deviceId));
}
}
/**
* 断言XML消息格式正确
*/
public static void assertValidXmlMessage(String xmlContent, String message) {
if (xmlContent == null || xmlContent.trim().isEmpty()) {
throw new AssertionError(message + " - XML内容不能为空");
}
if (!xmlContent.trim().startsWith("<?xml")) {
throw new AssertionError(message + " - XML内容应以XML声明开始");
}
// 简单的XML格式检查
long openTags = xmlContent.chars().filter(ch -> ch == '<').count();
long closeTags = xmlContent.chars().filter(ch -> ch == '>').count();
if (openTags != closeTags) {
throw new AssertionError(String.format("%s - XML标签不匹配, 开始标签: %d, 结束标签: %d",
message, openTags, closeTags));
}
}
/**
* 断言XML消息包含指定标签
*/
public static void assertXmlContainsTag(String xmlContent, String tagName, String message) {
assertValidXmlMessage(xmlContent, message);
String openTag = "<" + tagName;
String closeTag = "</" + tagName + ">";
if (!xmlContent.contains(openTag)) {
throw new AssertionError(String.format("%s - XML内容不包含标签 '%s'", message, tagName));
}
}
/**
* 断言XML消息包含指定标签和值
*/
public static void assertXmlContainsTagWithValue(String xmlContent, String tagName,
String expectedValue, String message) {
assertXmlContainsTag(xmlContent, tagName, message);
String pattern = "<" + tagName + "[^>]*>" + expectedValue + "</" + tagName + ">";
if (!xmlContent.matches(".*" + pattern + ".*")) {
throw new AssertionError(String.format("%s - XML标签 '%s' 的值不是期望的 '%s'",
message, tagName, expectedValue));
}
}
/**
* 断言超时内完成操作
*/
public static void assertCompletesWithinTimeout(Runnable operation, long timeoutMs, String message) {
long startTime = System.currentTimeMillis();
try {
operation.run();
} catch (Exception e) {
throw new AssertionError(message + " - 操作执行失败: " + e.getMessage(), e);
}
long duration = System.currentTimeMillis() - startTime;
if (duration > timeoutMs) {
throw new AssertionError(String.format("%s - 操作超时, 期望: %dms, 实际: %dms",
message, timeoutMs, duration));
}
}
/**
* 断言异步操作在超时内完成
*/
public static <T> T assertCompletesWithinTimeout(Supplier<CompletableFuture<T>> futureSupplier,
long timeoutMs, String message) {
try {
CompletableFuture<T> future = futureSupplier.get();
return future.get(timeoutMs, TimeUnit.MILLISECONDS);
} catch (Exception e) {
throw new AssertionError(String.format("%s - 异步操作超时或失败: %s", message, e.getMessage()), e);
}
}
/**
* 断言设备注册状态
*/
public static void assertDeviceRegistered(String deviceId, boolean expectedRegistered, String message) {
// 这里应该查询实际的设备注册状态
// 为了演示，假设有一个设备状态查询方法
log.debug("检查设备注册状态: {}", deviceId);
// 实际实现中应该调用设备管理服务查询状态
// boolean actualRegistered = deviceManager.isDeviceRegistered(deviceId);
// 这里暂时用日志代替
log.info("{} - 设备 {} 注册状态检查: 期望={}", message, deviceId, expectedRegistered);
}
/**
* 断言设备在线状态
*/
public static void assertDeviceOnline(String deviceId, boolean expectedOnline, String message) {
// 这里应该查询实际的设备在线状态
log.debug("检查设备在线状态: {}", deviceId);
// 实际实现中应该调用设备管理服务查询状态
// boolean actualOnline = deviceManager.isDeviceOnline(deviceId);
log.info("{} - 设备 {} 在线状态检查: 期望={}", message, deviceId, expectedOnline);
}
/**
* 断言SIP会话存在
*/
public static void assertSipSessionExists(String callId, String message) {
if (callId == null || callId.trim().isEmpty()) {
throw new AssertionError(message + " - Call-ID不能为空");
}
// 这里应该查询实际的SIP会话状态
log.debug("检查SIP会话: {}", callId);
// 实际实现中应该调用SIP会话管理器查询
// boolean sessionExists = sipSessionManager.sessionExists(callId);
log.info("{} - SIP会话 {} 存在性检查", message, callId);
}
/**
* 断言媒体流活跃
*/
public static void assertMediaStreamActive(String streamId, boolean expectedActive, String message) {
if (streamId == null || streamId.trim().isEmpty()) {
throw new AssertionError(message + " - 流ID不能为空");
}
// 这里应该查询实际的媒体流状态
log.debug("检查媒体流状态: {}", streamId);
// 实际实现中应该调用媒体服务器查询流状态
// boolean actualActive = mediaServer.isStreamActive(streamId);
log.info("{} - 媒体流 {} 活跃状态检查: 期望={}", message, streamId, expectedActive);
}
/**
* 断言数值在指定范围内
*/
public static void assertValueInRange(double actualValue, double minValue, double maxValue, String message) {
if (actualValue < minValue || actualValue > maxValue) {
throw new AssertionError(String.format("%s - 数值超出范围, 期望: [%.2f, %.2f], 实际: %.2f",
message, minValue, maxValue, actualValue));
}
}
/**
* 断言执行时间在合理范围内
*/
public static void assertExecutionTimeReasonable(long actualMs, long maxExpectedMs, String message) {
if (actualMs > maxExpectedMs) {
throw new AssertionError(String.format("%s - 执行时间过长, 期望最大: %dms, 实际: %dms",
message, maxExpectedMs, actualMs));
}
if (actualMs < 0) {
throw new AssertionError(String.format("%s - 执行时间异常, 实际: %dms", message, actualMs));
}
}
/**
* 断言字符串不为空且符合模式
*/
public static void assertStringMatchesPattern(String actualValue, String pattern, String message) {
if (actualValue == null) {
throw new AssertionError(message + " - 字符串不能为null");
}
if (actualValue.trim().isEmpty()) {
throw new AssertionError(message + " - 字符串不能为空");
}
if (!actualValue.matches(pattern)) {
throw new AssertionError(String.format("%s - 字符串不匹配模式, 期望模式: %s, 实际值: %s",
message, pattern, actualValue));
}
}
/**
* 软断言 - 记录失败但不抛出异常
*/
public static boolean softAssert(boolean condition, String message) {
if (!condition) {
log.error("软断言失败: {}", message);
return false;
}
return true;
}
/**
* 记录断言成功
*/
public static void logAssertionSuccess(String message) {
log.info("✓ 断言成功: {}", message);
}
/**
* 记录断言失败
*/
public static void logAssertionFailure(String message, Throwable cause) {
log.error("✗ 断言失败: {}", message, cause);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/util/TestDataGenerator.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/util/TestDataGenerator.java | package io.github.lunasaw.gbproxy.test.util;
import io.github.lunasaw.gb28181.common.entity.response.DeviceItem;
import io.github.lunasaw.gb28181.common.entity.response.DeviceCatalog;
import io.github.lunasaw.gb28181.common.entity.response.DeviceInfo;
import io.github.lunasaw.gb28181.common.entity.response.DeviceStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* 测试数据生成器
* 负责生成各种测试场景所需的模拟数据
*/
@Slf4j
@Component
public class TestDataGenerator {
private final Random random = new Random();
private final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
/**
* 生成设备信息
*/
public DeviceInfo generateDeviceInfo(String deviceId) {
DeviceInfo deviceInfo = new DeviceInfo();
deviceInfo.setDeviceId(deviceId);
deviceInfo.setDeviceName("测试设备-" + deviceId.substring(deviceId.length() - 4));
deviceInfo.setManufacturer("测试厂商");
deviceInfo.setModel("TestModel-" + random.nextInt(100));
deviceInfo.setFirmware("V" + random.nextInt(5) + "." + random.nextInt(10) + "." + random.nextInt(10));
deviceInfo.setChannel(random.nextInt(32) + 1);
deviceInfo.setResult("OK");
return deviceInfo;
}
/**
* 生成设备状态
*/
public DeviceStatus generateDeviceStatus(String deviceId) {
DeviceStatus deviceStatus = new DeviceStatus();
deviceStatus.setDeviceId(deviceId);
deviceStatus.setResult("OK");
deviceStatus.setOnline(random.nextBoolean() ? "ONLINE" : "OFFLINE");
deviceStatus.setStatus(random.nextBoolean() ? "OK" : "ERROR");
return deviceStatus;
}
/**
* 生成设备目录
*/
public DeviceCatalog generateDeviceCatalog(String deviceId, int channelCount) {
DeviceCatalog catalog = new DeviceCatalog();
catalog.setDeviceId(deviceId);
catalog.setName("测试设备目录");
catalog.setManufacturer("测试厂商");
catalog.setModel("TestModel");
catalog.setOwner("Admin");
catalog.setCivilCode(deviceId.substring(0, 6));
catalog.setAddress("测试地址");
catalog.setParental(0);
catalog.setParentId("");
catalog.setSafetyWay(0);
catalog.setRegisterWay(1);
catalog.setSecrecy(0);
catalog.setStatus("ON");
return catalog;
}
/**
* 生成设备通道项
*/
public DeviceItem generateDeviceItem(String parentId, int channelIndex) {
DeviceItem item = new DeviceItem();
// 生成通道ID（在父设备ID基础上修改最后几位）
String channelId = parentId.substring(0, 10) + String.format("%010d", channelIndex);
item.setDeviceId(channelId);
item.setName("通道-" + channelIndex);
item.setManufacturer("测试厂商");
item.setModel("TestChannel");
item.setOwner("Admin");
item.setCivilCode(parentId.substring(0, 6));
item.setAddress("测试地址-" + channelIndex);
item.setParental(1);
item.setParentId(parentId);
item.setSafetyWay(0);
item.setRegisterWay(1);
item.setSecrecy(0);
item.setStatus("ON");
return item;
}
/**
* 生成随机设备ID
*/
public String generateDeviceId(String prefix) {
if (prefix == null) {
prefix = "44050100";
}
// 确保前缀长度正确
if (prefix.length() > 8) {
prefix = prefix.substring(0, 8);
} else if (prefix.length() < 8) {
prefix = String.format("%-8s", prefix).replace(' ', '0');
}
// 生成12位随机数字
StringBuilder sb = new StringBuilder(prefix);
for (int i = 0; i < 12; i++) {
sb.append(random.nextInt(10));
}
return sb.toString();
}
/**
* 生成SIP Call-ID
*/
public String generateCallId() {
return "call-" + System.currentTimeMillis() + "-" + random.nextInt(10000);
}
/**
* 生成SIP Via分支
*/
public String generateViaBranch() {
return "z9hG4bK-" + System.currentTimeMillis() + "-" + random.nextInt(10000);
}
/**
* 生成SIP Tag
*/
public String generateTag() {
return "tag-" + System.currentTimeMillis() + "-" + random.nextInt(10000);
}
/**
* 生成随机IP地址（测试用）
*/
public String generateTestIpAddress() {
return "192.168." + random.nextInt(256) + "." + (random.nextInt(254) + 1);
}
/**
* 生成随机端口号
*/
public int generateTestPort() {
return 5000 + random.nextInt(55000);
}
/**
* 生成测试用户名
*/
public String generateTestUsername() {
String[] prefixes = {"test", "user", "device", "client"};
String prefix = prefixes[random.nextInt(prefixes.length)];
return prefix + "_" + random.nextInt(1000);
}
/**
* 生成测试密码
*/
public String generateTestPassword() {
String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
StringBuilder password = new StringBuilder();
int length = 8 + random.nextInt(8); // 8-15位
for (int i = 0; i < length; i++) {
password.append(chars.charAt(random.nextInt(chars.length())));
}
return password.toString();
}
/**
* 生成XML格式的设备信息查询响应
*/
public String generateDeviceInfoXml(String deviceId) {
DeviceInfo deviceInfo = generateDeviceInfo(deviceId);
return String.format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<Response>\n" +
" <CmdType>DeviceInfo</CmdType>\n" +
" <SN>%d</SN>\n" +
" <DeviceID>%s</DeviceID>\n" +
" <DeviceName>%s</DeviceName>\n" +
" <Manufacturer>%s</Manufacturer>\n" +
" <Model>%s</Model>\n" +
" <Firmware>%s</Firmware>\n" +
" <Channel>%d</Channel>\n" +
" <Result>OK</Result>\n" +
"</Response>",
System.currentTimeMillis() % 100000,
deviceInfo.getDeviceId(),
deviceInfo.getDeviceName(),
deviceInfo.getManufacturer(),
deviceInfo.getModel(),
deviceInfo.getFirmware(),
deviceInfo.getChannel()
);
}
/**
* 生成XML格式的设备状态查询响应
*/
public String generateDeviceStatusXml(String deviceId) {
DeviceStatus deviceStatus = generateDeviceStatus(deviceId);
return String.format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<Response>\n" +
" <CmdType>DeviceStatus</CmdType>\n" +
" <SN>%d</SN>\n" +
" <DeviceID>%s</DeviceID>\n" +
" <Result>%s</Result>\n" +
" <Online>%s</Online>\n" +
" <Status>%s</Status>\n" +
"</Response>",
System.currentTimeMillis() % 100000,
deviceStatus.getDeviceId(),
deviceStatus.getResult(),
deviceStatus.getOnline(),
deviceStatus.getStatus()
);
}
/**
* 生成XML格式的目录查询响应
*/
public String generateCatalogXml(String deviceId, int channelCount) {
DeviceCatalog catalog = generateDeviceCatalog(deviceId, channelCount);
StringBuilder xml = new StringBuilder();
xml.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
xml.append("<Response>\n");
xml.append(" <CmdType>Catalog</CmdType>\n");
xml.append(" <SN>").append(System.currentTimeMillis() % 100000).append("</SN>\n");
xml.append(" <DeviceID>").append(catalog.getDeviceId()).append("</DeviceID>\n");
xml.append(" <SumNum>").append(channelCount).append("</SumNum>\n");
xml.append(" <DeviceList Num=\"").append(channelCount).append("\">\n");
for (int i = 1; i <= channelCount; i++) {
DeviceItem item = generateDeviceItem(deviceId, i);
xml.append(" <Item>\n");
xml.append(" <DeviceID>").append(item.getDeviceId()).append("</DeviceID>\n");
xml.append(" <Name>").append(item.getName()).append("</Name>\n");
xml.append(" <Manufacturer>").append(item.getManufacturer()).append("</Manufacturer>\n");
xml.append(" <Model>").append(item.getModel()).append("</Model>\n");
xml.append(" <Owner>").append(item.getOwner()).append("</Owner>\n");
xml.append(" <CivilCode>").append(item.getCivilCode()).append("</CivilCode>\n");
xml.append(" <Address>").append(item.getAddress()).append("</Address>\n");
xml.append(" <Parental>").append(item.getParental()).append("</Parental>\n");
xml.append(" <ParentID>").append(item.getParentId()).append("</ParentID>\n");
xml.append(" <SafetyWay>").append(item.getSafetyWay()).append("</SafetyWay>\n");
xml.append(" <RegisterWay>").append(item.getRegisterWay()).append("</RegisterWay>\n");
xml.append(" <Secrecy>").append(item.getSecrecy()).append("</Secrecy>\n");
xml.append(" <Status>").append(item.getStatus()).append("</Status>\n");
xml.append(" </Item>\n");
}
xml.append(" </DeviceList>\n");
xml.append("</Response>\n");
return xml.toString();
}
/**
* 生成随机延迟（毫秒）
*/
public long generateRandomDelay(int minMs, int maxMs) {
return minMs + random.nextInt(maxMs - minMs + 1);
}
/**
* 生成随机布尔值（指定概率）
*/
public boolean generateRandomBoolean(double trueProbability) {
return random.nextDouble() < trueProbability;
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/utils/TestSipRequestUtils.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/utils/TestSipRequestUtils.java | package io.github.lunasaw.gbproxy.test.utils;
import javax.sip.header.CallIdHeader;
import javax.sip.header.HeaderFactory;
import javax.sip.message.MessageFactory;
import java.text.ParseException;
import java.util.UUID;
/**
* 测试专用的SIP请求工具类
* 提供不依赖SipLayer的工具方法
*
* @author luna
* @date 2025/01/23
*/
public class TestSipRequestUtils {
private static final MessageFactory MESSAGE_FACTORY;
private static final HeaderFactory HEADER_FACTORY;
static {
try {
MESSAGE_FACTORY = javax.sip.SipFactory.getInstance().createMessageFactory();
HEADER_FACTORY = javax.sip.SipFactory.getInstance().createHeaderFactory();
} catch (javax.sip.PeerUnavailableException e) {
throw new RuntimeException("初始化SIP工厂失败", e);
}
}
/**
* 生成新的CallId
* 使用UUID生成，不依赖SipLayer
*
* @return CallId字符串
*/
public static String getNewCallId() {
return UUID.randomUUID().toString().replace("-", "");
}
/**
* 创建CallIdHeader
* 使用UUID生成，不依赖SipLayer
*
* @return CallIdHeader
*/
public static CallIdHeader getNewCallIdHeader() {
try {
return HEADER_FACTORY.createCallIdHeader(getNewCallId());
} catch (ParseException e) {
throw new RuntimeException("创建CallIdHeader失败", e);
}
}
/**
* 根据指定CallId创建CallIdHeader
*
* @param callId CallId字符串
* @return CallIdHeader
*/
public static CallIdHeader createCallIdHeader(String callId) {
try {
if (callId == null) {
return getNewCallIdHeader();
}
return HEADER_FACTORY.createCallIdHeader(callId);
} catch (ParseException e) {
throw new RuntimeException("创建CallIdHeader失败", e);
}
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/runner/AutoTestRunner.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/runner/AutoTestRunner.java | package io.github.lunasaw.gbproxy.test.runner;
import io.github.lunasaw.gbproxy.test.config.TestSuiteConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 自动化测试执行器
* 负责组织和执行各种测试套件
*/
@Slf4j
@Component
public class AutoTestRunner {
@Autowired
private TestSuiteConfig testSuiteConfig;
@Autowired
private TestReportGenerator reportGenerator;
@Autowired
private TestMetricsCollector metricsCollector;
private ExecutorService executorService;
/**
* 运行测试套件
*/
public void runTestSuite() {
log.info("开始执行测试套件 - 模式: {}, 套件: {}",
testSuiteConfig.getMode(), testSuiteConfig.getSuite());
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss"));
String sessionId = "test-session-" + timestamp;
// 初始化测试环境
initializeTestEnvironment();
try {
// 开始收集指标
metricsCollector.startCollection(sessionId);
// 根据配置执行相应的测试套件
switch (testSuiteConfig.getSuite().toLowerCase()) {
case "all":
runAllTests();
break;
case "server":
runServerTests();
break;
case "client":
runClientTests();
break;
case "integration":
runIntegrationTests();
break;
default:
log.warn("未知的测试套件类型: {}", testSuiteConfig.getSuite());
runAllTests();
}
} catch (Exception e) {
log.error("测试执行失败", e);
throw new RuntimeException("测试执行失败", e);
} finally {
// 停止收集指标
metricsCollector.stopCollection();
// 生成测试报告
if (testSuiteConfig.isReport()) {
reportGenerator.generateReport(sessionId);
}
// 清理测试环境
cleanupTestEnvironment();
}
}
/**
* 运行所有测试
*/
private void runAllTests() {
log.info("执行完整测试套件...");
if (testSuiteConfig.isConcurrent()) {
runTestsConcurrently();
} else {
runTestsSequentially();
}
}
/**
* 并发执行测试
*/
private void runTestsConcurrently() {
log.info("并发执行测试...");
CompletableFuture<Void> serverTests = CompletableFuture.runAsync(this::runServerTests, executorService);
CompletableFuture<Void> clientTests = CompletableFuture.runAsync(this::runClientTests, executorService);
// 等待所有测试完成
CompletableFuture.allOf(serverTests, clientTests).join();
// 最后执行集成测试
runIntegrationTests();
}
/**
* 顺序执行测试
*/
private void runTestsSequentially() {
log.info("顺序执行测试...");
runServerTests();
runClientTests();
runIntegrationTests();
}
/**
* 运行服务端测试
*/
private void runServerTests() {
log.info("========================================");
log.info("开始执行服务端功能测试");
log.info("========================================");
try {
// 设备管理测试
executeTestGroup("服务端设备管理测试", () -> {
log.info("执行设备注册管理测试...");
log.info("执行设备认证测试...");
log.info("执行设备状态监控测试...");
log.info("执行设备目录管理测试...");
});
// 命令控制测试
executeTestGroup("服务端命令控制测试", () -> {
log.info("执行云台控制测试...");
log.info("执行录像控制测试...");
log.info("执行设备配置测试...");
log.info("执行告警控制测试...");
});
// 媒体流测试
executeTestGroup("服务端媒体流测试", () -> {
log.info("执行实时点播测试...");
log.info("执行历史回放测试...");
log.info("执行媒体协商测试...");
log.info("执行流控制测试...");
});
} catch (Exception e) {
log.error("服务端测试执行失败", e);
if (!testSuiteConfig.isContinueOnFailure()) {
throw e;
}
}
log.info("服务端功能测试执行完成");
}
/**
* 运行客户端测试
*/
private void runClientTests() {
log.info("========================================");
log.info("开始执行客户端功能测试");
log.info("========================================");
try {
// 设备模拟测试
executeTestGroup("客户端设备模拟测试", () -> {
log.info("执行设备注册测试...");
log.info("执行心跳保活测试...");
log.info("执行状态上报测试...");
log.info("执行设备离线恢复测试...");
});
// 命令响应测试
executeTestGroup("客户端命令响应测试", () -> {
log.info("执行控制命令响应测试...");
log.info("执行查询命令应答测试...");
log.info("执行订阅消息处理测试...");
log.info("执行错误处理测试...");
});
// 媒体响应测试
executeTestGroup("客户端媒体响应测试", () -> {
log.info("执行INVITE响应测试...");
log.info("执行媒体协商测试...");
log.info("执行BYE处理测试...");
});
} catch (Exception e) {
log.error("客户端测试执行失败", e);
if (!testSuiteConfig.isContinueOnFailure()) {
throw e;
}
}
log.info("客户端功能测试执行完成");
}
/**
* 运行集成测试
*/
private void runIntegrationTests() {
log.info("========================================");
log.info("开始执行集成测试");
log.info("========================================");
try {
// 协议兼容性测试
executeTestGroup("协议兼容性测试", () -> {
log.info("执行GB28181标准符合性测试...");
log.info("执行SIP协议兼容性测试...");
log.info("执行XML消息格式验证...");
});
// 性能测试
executeTestGroup("性能测试", () -> {
log.info("执行并发设备注册测试...");
log.info("执行大量消息处理测试...");
log.info("执行内存和CPU使用率测试...");
});
// 稳定性测试
executeTestGroup("稳定性测试", () -> {
log.info("执行长时间运行测试...");
log.info("执行异常恢复测试...");
log.info("执行网络中断恢复测试...");
});
} catch (Exception e) {
log.error("集成测试执行失败", e);
if (!testSuiteConfig.isContinueOnFailure()) {
throw e;
}
}
log.info("集成测试执行完成");
}
/**
* 执行测试组
*/
private void executeTestGroup(String groupName, Runnable testGroup) {
log.info(">>> 开始执行: {}", groupName);
long startTime = System.currentTimeMillis();
try {
testGroup.run();
long duration = System.currentTimeMillis() - startTime;
log.info(">>> 完成: {} (耗时: {}ms)", groupName, duration);
// 测试间隔
if (testSuiteConfig.getInterval() > 0) {
Thread.sleep(testSuiteConfig.getInterval());
}
} catch (Exception e) {
log.error(">>> 失败: {}", groupName, e);
throw new RuntimeException("测试组执行失败: " + groupName, e);
}
}
/**
* 初始化测试环境
*/
private void initializeTestEnvironment() {
log.info("初始化测试环境...");
if (testSuiteConfig.isConcurrent()) {
int poolSize = Runtime.getRuntime().availableProcessors();
executorService = Executors.newFixedThreadPool(poolSize);
log.info("初始化线程池，大小: {}", poolSize);
}
// 创建测试输出目录
reportGenerator.initializeOutputDirectory();
log.info("测试环境初始化完成");
}
/**
* 清理测试环境
*/
private void cleanupTestEnvironment() {
log.info("清理测试环境...");
if (executorService != null && !executorService.isShutdown()) {
executorService.shutdown();
}
log.info("测试环境清理完成");
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/runner/TestReportGenerator.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/runner/TestReportGenerator.java | package io.github.lunasaw.gbproxy.test.runner;
import io.github.lunasaw.gbproxy.test.config.TestSuiteConfig;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
/**
* 测试报告生成器
* 负责生成详细的测试执行报告
*/
@Slf4j
@Component
public class TestReportGenerator {
@Autowired
private TestSuiteConfig testSuiteConfig;
@Autowired
private TestMetricsCollector metricsCollector;
private List<TestResult> testResults = new ArrayList<>();
/**
* 初始化输出目录
*/
public void initializeOutputDirectory() {
File outputDir = new File(testSuiteConfig.getOutputDir());
if (!outputDir.exists()) {
boolean created = outputDir.mkdirs();
if (created) {
log.info("创建测试输出目录: {}", outputDir.getAbsolutePath());
} else {
log.warn("无法创建测试输出目录: {}", outputDir.getAbsolutePath());
}
}
}
/**
* 添加测试结果
*/
public void addTestResult(String testName, String testGroup, boolean success,
long duration, String details, Throwable error) {
TestResult result = new TestResult();
result.setTestName(testName);
result.setTestGroup(testGroup);
result.setSuccess(success);
result.setDuration(duration);
result.setDetails(details);
result.setError(error);
result.setTimestamp(LocalDateTime.now());
testResults.add(result);
if (testSuiteConfig.isVerbose()) {
log.info("测试结果: {} - {} - {} ({}ms)",
testGroup, testName, success ? "成功" : "失败", duration);
}
}
/**
* 生成测试报告
*/
public void generateReport(String sessionId) {
log.info("开始生成测试报告...");
try {
// 生成HTML报告
generateHtmlReport(sessionId);
// 生成JSON报告
generateJsonReport(sessionId);
// 生成控制台摘要
generateConsoleSummary();
log.info("测试报告生成完成，输出目录: {}", testSuiteConfig.getOutputDir());
} catch (Exception e) {
log.error("生成测试报告失败", e);
}
}
/**
* 生成HTML报告
*/
private void generateHtmlReport(String sessionId) throws IOException {
String fileName = String.format("%s/test-report-%s.html",
testSuiteConfig.getOutputDir(), sessionId);
try (FileWriter writer = new FileWriter(fileName)) {
writer.write(generateHtmlContent(sessionId));
}
log.info("HTML测试报告已生成: {}", fileName);
}
/**
* 生成HTML内容
*/
private String generateHtmlContent(String sessionId) {
StringBuilder html = new StringBuilder();
// HTML头部
html.append("<!DOCTYPE html>\n");
html.append("<html lang='zh-CN'>\n");
html.append("<head>\n");
html.append(" <meta charset='UTF-8'>\n");
html.append(" <title>GB28181测试报告 - ").append(sessionId).append("</title>\n");
html.append(" <style>\n");
html.append(getHtmlStyles());
html.append(" </style>\n");
html.append("</head>\n");
html.append("<body>\n");
// 报告头部
html.append(" <h1>GB28181功能测试报告</h1>\n");
html.append(" <div class='summary'>\n");
html.append(" <h2>测试摘要</h2>\n");
html.append(" <table>\n");
html.append(" <tr><td>会话ID:</td><td>").append(sessionId).append("</td></tr>\n");
html.append(" <tr><td>测试时间:</td><td>").append(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))).append("</td></tr>\n");
html.append(" <tr><td>测试模式:</td><td>").append(testSuiteConfig.getMode()).append("</td></tr>\n");
html.append(" <tr><td>测试套件:</td><td>").append(testSuiteConfig.getSuite()).append("</td></tr>\n");
html.append(" <tr><td>总测试数:</td><td>").append(testResults.size()).append("</td></tr>\n");
html.append(" <tr><td>成功数:</td><td class='success'>").append(getSuccessCount()).append("</td></tr>\n");
html.append(" <tr><td>失败数:</td><td class='failure'>").append(getFailureCount()).append("</td></tr>\n");
html.append(" <tr><td>成功率:</td><td>").append(String.format("%.2f%%", getSuccessRate())).append("</td></tr>\n");
html.append(" </table>\n");
html.append(" </div>\n");
// 测试结果详情
html.append(" <div class='details'>\n");
html.append(" <h2>测试结果详情</h2>\n");
html.append(" <table>\n");
html.append(" <thead>\n");
html.append(" <tr>\n");
html.append(" <th>测试组</th>\n");
html.append(" <th>测试名称</th>\n");
html.append(" <th>结果</th>\n");
html.append(" <th>耗时(ms)</th>\n");
html.append(" <th>时间</th>\n");
html.append(" <th>详情</th>\n");
html.append(" </tr>\n");
html.append(" </thead>\n");
html.append(" <tbody>\n");
for (TestResult result : testResults) {
html.append(" <tr class='").append(result.isSuccess() ? "success" : "failure").append("'>\n");
html.append(" <td>").append(result.getTestGroup()).append("</td>\n");
html.append(" <td>").append(result.getTestName()).append("</td>\n");
html.append(" <td>").append(result.isSuccess() ? "成功" : "失败").append("</td>\n");
html.append(" <td>").append(result.getDuration()).append("</td>\n");
html.append(" <td>").append(result.getTimestamp().format(DateTimeFormatter.ofPattern("HH:mm:ss"))).append("</td>\n");
html.append(" <td>").append(result.getDetails() != null ? result.getDetails() : "").append("</td>\n");
html.append(" </tr>\n");
}
html.append(" </tbody>\n");
html.append(" </table>\n");
html.append(" </div>\n");
// 性能指标
if (metricsCollector.hasMetrics()) {
html.append(" <div class='metrics'>\n");
html.append(" <h2>性能指标</h2>\n");
html.append(" <div class='metrics-content'>\n");
html.append(metricsCollector.getMetricsHtml());
html.append(" </div>\n");
html.append(" </div>\n");
}
html.append("</body>\n");
html.append("</html>\n");
return html.toString();
}
/**
* 获取HTML样式
*/
private String getHtmlStyles() {
return "body { font-family: Arial, sans-serif; margin: 20px; }\n" +
"h1 { color: #333; text-align: center; }\n" +
"h2 { color: #666; border-bottom: 2px solid #eee; padding-bottom: 5px; }\n" +
".summary table, .details table { width: 100%; border-collapse: collapse; margin: 10px 0; }\n" +
".summary td, .details th, .details td { padding: 8px; border: 1px solid #ddd; text-align: left; }\n" +
".summary td:first-child { font-weight: bold; background-color: #f5f5f5; width: 120px; }\n" +
".details th { background-color: #f5f5f5; font-weight: bold; }\n" +
".success { color: #28a745; }\n" +
".failure { color: #dc3545; }\n" +
"tr.success { background-color: #d4edda; }\n" +
"tr.failure { background-color: #f8d7da; }\n" +
".metrics { margin-top: 30px; }\n" +
".metrics-content { background-color: #f8f9fa; padding: 15px; border-radius: 5px; }";
}
/**
* 生成JSON报告
*/
private void generateJsonReport(String sessionId) throws IOException {
String fileName = String.format("%s/test-report-%s.json",
testSuiteConfig.getOutputDir(), sessionId);
StringBuilder json = new StringBuilder();
json.append("{\n");
json.append(" \"sessionId\": \"").append(sessionId).append("\",\n");
json.append(" \"timestamp\": \"").append(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)).append("\",\n");
json.append(" \"config\": {\n");
json.append(" \"mode\": \"").append(testSuiteConfig.getMode()).append("\",\n");
json.append(" \"suite\": \"").append(testSuiteConfig.getSuite()).append("\",\n");
json.append(" \"concurrent\": ").append(testSuiteConfig.isConcurrent()).append("\n");
json.append(" },\n");
json.append(" \"summary\": {\n");
json.append(" \"total\": ").append(testResults.size()).append(",\n");
json.append(" \"success\": ").append(getSuccessCount()).append(",\n");
json.append(" \"failure\": ").append(getFailureCount()).append(",\n");
json.append(" \"successRate\": ").append(String.format("%.2f", getSuccessRate())).append("\n");
json.append(" },\n");
json.append(" \"results\": [\n");
for (int i = 0; i < testResults.size(); i++) {
TestResult result = testResults.get(i);
json.append(" {\n");
json.append(" \"testGroup\": \"").append(result.getTestGroup()).append("\",\n");
json.append(" \"testName\": \"").append(result.getTestName()).append("\",\n");
json.append(" \"success\": ").append(result.isSuccess()).append(",\n");
json.append(" \"duration\": ").append(result.getDuration()).append(",\n");
json.append(" \"timestamp\": \"").append(result.getTimestamp().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)).append("\"\n");
json.append(" }");
if (i < testResults.size() - 1) {
json.append(",");
}
json.append("\n");
}
json.append(" ]\n");
json.append("}\n");
try (FileWriter writer = new FileWriter(fileName)) {
writer.write(json.toString());
}
log.info("JSON测试报告已生成: {}", fileName);
}
/**
* 生成控制台摘要
*/
private void generateConsoleSummary() {
log.info("========================================");
log.info(" 测试执行摘要");
log.info("========================================");
log.info("总测试数: {}", testResults.size());
log.info("成功数: {}", getSuccessCount());
log.info("失败数: {}", getFailureCount());
log.info("成功率: {:.2f}%", getSuccessRate());
if (getFailureCount() > 0) {
log.info("========================================");
log.info(" 失败测试详情");
log.info("========================================");
testResults.stream()
.filter(result -> !result.isSuccess())
.forEach(result -> log.error("失败: {} - {} ({}ms)",
result.getTestGroup(), result.getTestName(), result.getDuration()));
}
log.info("========================================");
}
/**
* 获取成功测试数量
*/
private long getSuccessCount() {
return testResults.stream().mapToLong(result -> result.isSuccess() ? 1 : 0).sum();
}
/**
* 获取失败测试数量
*/
private long getFailureCount() {
return testResults.stream().mapToLong(result -> result.isSuccess() ? 0 : 1).sum();
}
/**
* 获取成功率
*/
private double getSuccessRate() {
if (testResults.isEmpty()) {
return 0.0;
}
return (double) getSuccessCount() / testResults.size() * 100;
}
/**
* 测试结果数据类
*/
@Data
public static class TestResult {
private String testName;
private String testGroup;
private boolean success;
private long duration;
private String details;
private Throwable error;
private LocalDateTime timestamp;
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/runner/TestMetricsCollector.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/runner/TestMetricsCollector.java | package io.github.lunasaw.gbproxy.test.runner;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
/**
* 测试指标收集器
* 负责收集测试过程中的各种性能指标
*/
@Slf4j
@Component
public class TestMetricsCollector {
private final Map<String, AtomicLong> counters = new ConcurrentHashMap<>();
private final Map<String, Double> gauges = new ConcurrentHashMap<>();
private final Map<String, Long> timers = new ConcurrentHashMap<>();
private boolean collecting = false;
private String currentSessionId;
private LocalDateTime startTime;
private LocalDateTime endTime;
/**
* 开始收集指标
*/
public void startCollection(String sessionId) {
log.info("开始收集测试指标，会话ID: {}", sessionId);
this.currentSessionId = sessionId;
this.startTime = LocalDateTime.now();
this.collecting = true;
// 初始化基础指标
initializeMetrics();
// 启动系统资源监控
startSystemMonitoring();
}
/**
* 停止收集指标
*/
public void stopCollection() {
if (!collecting) {
return;
}
this.endTime = LocalDateTime.now();
this.collecting = false;
log.info("停止收集测试指标，会话ID: {}", currentSessionId);
// 记录最终指标
recordFinalMetrics();
}
/**
* 初始化指标
*/
private void initializeMetrics() {
// 测试计数器
counters.put("test.total", new AtomicLong(0));
counters.put("test.success", new AtomicLong(0));
counters.put("test.failure", new AtomicLong(0));
// SIP消息计数器
counters.put("sip.request.sent", new AtomicLong(0));
counters.put("sip.response.received", new AtomicLong(0));
counters.put("sip.error", new AtomicLong(0));
// GB28181消息计数器
counters.put("gb28181.register", new AtomicLong(0));
counters.put("gb28181.keepalive", new AtomicLong(0));
counters.put("gb28181.catalog", new AtomicLong(0));
counters.put("gb28181.deviceinfo", new AtomicLong(0));
counters.put("gb28181.invite", new AtomicLong(0));
// 性能指标
gauges.put("memory.used.mb", 0.0);
gauges.put("memory.max.mb", 0.0);
gauges.put("cpu.usage.percent", 0.0);
gauges.put("thread.count", 0.0);
}
/**
* 启动系统资源监控
*/
private void startSystemMonitoring() {
Thread monitorThread = new Thread(() -> {
while (collecting) {
try {
// 记录内存使用情况
Runtime runtime = Runtime.getRuntime();
long usedMemory = runtime.totalMemory() - runtime.freeMemory();
long maxMemory = runtime.maxMemory();
gauges.put("memory.used.mb", usedMemory / 1024.0 / 1024.0);
gauges.put("memory.max.mb", maxMemory / 1024.0 / 1024.0);
// 记录线程数
gauges.put("thread.count", (double) Thread.activeCount());
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
} catch (Exception e) {
log.warn("系统监控异常", e);
}
}
});
monitorThread.setDaemon(true);
monitorThread.setName("test-metrics-monitor");
monitorThread.start();
}
/**
* 记录最终指标
*/
private void recordFinalMetrics() {
if (startTime != null && endTime != null) {
long durationMs = java.time.Duration.between(startTime, endTime).toMillis();
timers.put("test.total.duration.ms", durationMs);
}
// 计算成功率
long total = counters.get("test.total").get();
long success = counters.get("test.success").get();
if (total > 0) {
double successRate = (double) success / total * 100;
gauges.put("test.success.rate.percent", successRate);
}
log.info("测试指标收集完成");
logMetricsSummary();
}
/**
* 记录测试开始
*/
public void recordTestStart(String testName) {
if (!collecting) return;
counters.get("test.total").incrementAndGet();
timers.put("test." + testName + ".start", System.currentTimeMillis());
}
/**
* 记录测试成功
*/
public void recordTestSuccess(String testName) {
if (!collecting) return;
counters.get("test.success").incrementAndGet();
recordTestEnd(testName);
}
/**
* 记录测试失败
*/
public void recordTestFailure(String testName) {
if (!collecting) return;
counters.get("test.failure").incrementAndGet();
recordTestEnd(testName);
}
/**
* 记录测试结束
*/
private void recordTestEnd(String testName) {
String startKey = "test." + testName + ".start";
if (timers.containsKey(startKey)) {
long startTime = timers.get(startKey);
long duration = System.currentTimeMillis() - startTime;
timers.put("test." + testName + ".duration", duration);
timers.remove(startKey);
}
}
/**
* 记录SIP请求发送
*/
public void recordSipRequestSent(String method) {
if (!collecting) return;
counters.get("sip.request.sent").incrementAndGet();
counters.computeIfAbsent("sip.request." + method.toLowerCase(), k -> new AtomicLong(0)).incrementAndGet();
}
/**
* 记录SIP响应接收
*/
public void recordSipResponseReceived(int statusCode) {
if (!collecting) return;
counters.get("sip.response.received").incrementAndGet();
String category = getStatusCategory(statusCode);
counters.computeIfAbsent("sip.response." + category, k -> new AtomicLong(0)).incrementAndGet();
}
/**
* 记录SIP错误
*/
public void recordSipError(String errorType) {
if (!collecting) return;
counters.get("sip.error").incrementAndGet();
counters.computeIfAbsent("sip.error." + errorType, k -> new AtomicLong(0)).incrementAndGet();
}
/**
* 记录GB28181消息
*/
public void recordGb28181Message(String messageType) {
if (!collecting) return;
String key = "gb28181." + messageType.toLowerCase();
if (counters.containsKey(key)) {
counters.get(key).incrementAndGet();
}
}
/**
* 获取状态码分类
*/
private String getStatusCategory(int statusCode) {
if (statusCode >= 200 && statusCode < 300) {
return "2xx";
} else if (statusCode >= 300 && statusCode < 400) {
return "3xx";
} else if (statusCode >= 400 && statusCode < 500) {
return "4xx";
} else if (statusCode >= 500 && statusCode < 600) {
return "5xx";
}
return "other";
}
/**
* 输出指标摘要
*/
private void logMetricsSummary() {
log.info("========================================");
log.info(" 测试指标摘要");
log.info("========================================");
// 测试统计
log.info("测试统计:");
log.info(" 总测试数: {}", counters.get("test.total").get());
log.info(" 成功数: {}", counters.get("test.success").get());
log.info(" 失败数: {}", counters.get("test.failure").get());
if (gauges.containsKey("test.success.rate.percent")) {
log.info(" 成功率: {:.2f}%", gauges.get("test.success.rate.percent"));
}
// SIP统计
log.info("SIP消息统计:");
log.info(" 请求发送: {}", counters.get("sip.request.sent").get());
log.info(" 响应接收: {}", counters.get("sip.response.received").get());
log.info(" 错误数: {}", counters.get("sip.error").get());
// GB28181统计
log.info("GB28181消息统计:");
log.info(" 注册: {}", counters.get("gb28181.register").get());
log.info(" 心跳: {}", counters.get("gb28181.keepalive").get());
log.info(" 目录: {}", counters.get("gb28181.catalog").get());
log.info(" 设备信息: {}", counters.get("gb28181.deviceinfo").get());
log.info(" 邀请: {}", counters.get("gb28181.invite").get());
// 系统资源
log.info("系统资源:");
log.info(" 内存使用: {:.2f} MB / {:.2f} MB",
gauges.get("memory.used.mb"), gauges.get("memory.max.mb"));
log.info(" 线程数: {:.0f}", gauges.get("thread.count"));
// 执行时间
if (timers.containsKey("test.total.duration.ms")) {
log.info(" 总执行时间: {} ms", timers.get("test.total.duration.ms"));
}
}
/**
* 检查是否有指标数据
*/
public boolean hasMetrics() {
return !counters.isEmpty() || !gauges.isEmpty() || !timers.isEmpty();
}
/**
* 获取指标的HTML表示
*/
public String getMetricsHtml() {
StringBuilder html = new StringBuilder();
html.append("<h3>测试统计</h3>");
html.append("<ul>");
html.append("<li>总测试数: ").append(counters.get("test.total").get()).append("</li>");
html.append("<li>成功数: ").append(counters.get("test.success").get()).append("</li>");
html.append("<li>失败数: ").append(counters.get("test.failure").get()).append("</li>");
if (gauges.containsKey("test.success.rate.percent")) {
html.append("<li>成功率: ").append(String.format("%.2f%%", gauges.get("test.success.rate.percent"))).append("</li>");
}
html.append("</ul>");
html.append("<h3>SIP消息统计</h3>");
html.append("<ul>");
html.append("<li>请求发送: ").append(counters.get("sip.request.sent").get()).append("</li>");
html.append("<li>响应接收: ").append(counters.get("sip.response.received").get()).append("</li>");
html.append("<li>错误数: ").append(counters.get("sip.error").get()).append("</li>");
html.append("</ul>");
html.append("<h3>系统资源</h3>");
html.append("<ul>");
html.append("<li>内存使用: ").append(String.format("%.2f MB / %.2f MB",
gauges.get("memory.used.mb"), gauges.get("memory.max.mb"))).append("</li>");
html.append("<li>线程数: ").append(String.format("%.0f", gauges.get("thread.count"))).append("</li>");
if (timers.containsKey("test.total.duration.ms")) {
html.append("<li>总执行时间: ").append(timers.get("test.total.duration.ms")).append(" ms</li>");
}
html.append("</ul>");
return html.toString();
}
/**
* 获取计数器值
*/
public long getCounter(String name) {
return counters.getOrDefault(name, new AtomicLong(0)).get();
}
/**
* 获取度量值
*/
public double getGauge(String name) {
return gauges.getOrDefault(name, 0.0);
}
/**
* 获取计时器值
*/
public long getTimer(String name) {
return timers.getOrDefault(name, 0L);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestSuiteConfig.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestSuiteConfig.java | package io.github.lunasaw.gbproxy.test.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 测试套件配置类
* 管理测试执行的各种参数和选项
*/
@Data
@Component
@ConfigurationProperties(prefix = "test")
public class TestSuiteConfig {
/**
* 测试模式
* auto: 自动化测试，执行所有测试用例
* manual: 手动测试，提供交互式界面
*/
private String mode = "auto";
/**
* 测试套件选择
* all: 执行所有测试
* server: 仅执行服务端测试
* client: 仅执行客户端测试
* integration: 仅执行集成测试
*/
private String suite = "all";
/**
* 是否并发执行测试
*/
private boolean concurrent = false;
/**
* 是否生成测试报告
*/
private boolean report = true;
/**
* 测试超时时间（秒）
*/
private int timeout = 30;
/**
* 测试重试次数
*/
private int retryCount = 3;
/**
* 测试间隔时间（毫秒）
*/
private long interval = 1000;
/**
* 是否在测试失败时继续执行
*/
private boolean continueOnFailure = true;
/**
* 测试结果输出目录
*/
private String outputDir = "target/test-results";
/**
* 是否输出详细日志
*/
private boolean verbose = true;
/**
* 测试数据目录
*/
private String testDataDir = "src/test/resources/test-data";
/**
* 测试场景配置目录
*/
private String scenarioDir = "src/test/resources/test-scenarios";
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestDeviceSupplier.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestDeviceSupplier.java | package io.github.lunasaw.gbproxy.test.config;
import com.google.common.collect.Lists;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.service.DeviceSupplier;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import jakarta.annotation.PostConstruct;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import io.github.lunasaw.sip.common.service.ServerDeviceSupplier;
/**
* 测试设备提供器实现
* 专门用于测试环境，提供预配置的设备
*
* 设计原则：
* 1. 业务方通过userId获取设备数据，项目本身不关心设备类型
* 2. 统一存储Device对象，避免数据覆盖问题
* 3. 提供转换方法，在使用时根据场景转换为FromDevice或ToDevice
* 4. 支持动态设备管理和更新
*
* @author luna
* @date 2025/01/23
*/
@Slf4j
@Component
@Primary
@EnableConfigurationProperties(TestDeviceProperties.class)
public class TestDeviceSupplier implements DeviceSupplier, ClientDeviceSupplier, ServerDeviceSupplier {
private static final String LOOP_IP = "127.0.0.1";
@Autowired
private TestDeviceProperties testDeviceProperties;
/**
* 用户ID到设备的映射
* 统一存储Device对象，避免数据覆盖
*/
private final Map<String, Device> userIdMap = new ConcurrentHashMap<>();
private FromDevice clientFromDevice;
private FromDevice serverFromDevice;
@PostConstruct
public void initializeDevices() {
log.info("初始化测试设备配置...");
// 客户端设备配置
String clientId = testDeviceProperties.getClient().getClientId();
String clientIp = testDeviceProperties.getClient().getDomain() != null ? testDeviceProperties.getClient().getDomain() : "127.0.0.1";
int clientPort = 5061; // 可根据需要从配置读取
String clientRealm = testDeviceProperties.getServer().getRealm();
String clientPassword = testDeviceProperties.getServer().getPassword();
FromDevice clientFrom = FromDevice.getInstance(clientId, clientIp, clientPort);
clientFrom.setRealm(clientRealm);
clientFrom.setPassword(clientPassword);
addOrUpdateDevice(clientFrom);
ToDevice clientTo = ToDevice.getInstance(testDeviceProperties.getServer().getServerId(), clientIp, 5060);
clientTo.setRealm(clientRealm);
clientTo.setPassword(clientPassword);
addOrUpdateDevice(clientTo);
// 服务端设备配置
String serverId = testDeviceProperties.getServer().getServerId();
String serverIp = testDeviceProperties.getServer().getDomain() != null ? testDeviceProperties.getServer().getDomain() : "127.0.0.1";
int serverPort = 5060;
String serverRealm = testDeviceProperties.getServer().getRealm();
String serverPassword = testDeviceProperties.getServer().getPassword();
FromDevice serverFrom = FromDevice.getInstance(serverId, serverIp, serverPort);
serverFrom.setRealm(serverRealm);
serverFrom.setPassword(serverPassword);
addOrUpdateDevice(serverFrom);
ToDevice serverTo = ToDevice.getInstance(testDeviceProperties.getClient().getClientId(), serverIp, 5061);
serverTo.setRealm(serverRealm);
serverTo.setPassword(serverPassword);
addOrUpdateDevice(serverTo);
// 添加测试用的硬编码设备
addOrUpdateDevice(createClientFromDevice());
addOrUpdateDevice(createClientToDevice());
addOrUpdateDevice(createServerFromDevice());
addOrUpdateDevice(createServerToDevice());
}
/**
* 创建客户端From设备
*/
private Device createClientFromDevice() {
return FromDevice.getInstance("33010602011187000001", LOOP_IP, 5061);
}
/**
* 创建客户端To设备
*/
private Device createClientToDevice() {
ToDevice device = ToDevice.getInstance("41010500002000000001", LOOP_IP, 5060);
device.setPassword("bajiuwulian1006");
device.setRealm("4101050000");
return device;
}
/**
* 创建服务端From设备
*/
private Device createServerFromDevice() {
FromDevice device = FromDevice.getInstance("41010500002000000001", LOOP_IP, 5060);
device.setPassword("bajiuwulian1006");
device.setRealm("4101050000");
return device;
}
/**
* 创建服务端To设备
*/
private Device createServerToDevice() {
ToDevice device = ToDevice.getInstance("33010602011187000001", LOOP_IP, 5061);
return device;
}
public List<Device> getDevices() {
return Lists.newArrayList(userIdMap.values());
}
@Override
public Device getDevice(String userId) {
Device device = userIdMap.get(userId);
if (device == null) {
log.warn("未找到用户ID为 {} 的设备", userId);
}
return device;
}
public void addOrUpdateDevice(Device device) {
if (device == null) {
log.warn("尝试添加空设备");
return;
}
if (device.getUserId() == null || device.getUserId().trim().isEmpty()) {
log.warn("设备用户ID不能为空");
return;
}
// 更新用户ID映射 - 统一存储Device对象
userIdMap.put(device.getUserId(), device);
log.info("设备添加/更新成功 - 用户ID: {}, IP: {}:{}",
device.getUserId(), device.getIp(), device.getPort());
}
public void removeDevice(String userId) {
Device removedDevice = userIdMap.remove(userId);
if (removedDevice != null) {
log.info("设备移除成功 - 用户ID: {}", userId);
} else {
log.warn("未找到要移除的设备，用户ID: {}", userId);
}
}
public int getDeviceCount() {
return userIdMap.size();
}
@Override
public String getName() {
return "TestDeviceSupplier";
}
// ==================== 转换方法 ====================
/**
* 获取客户端From设备
* 用于客户端主动发送请求的场景
*/
public FromDevice getClientFromDevice() {
if (clientFromDevice != null) {
return clientFromDevice;
}
Device device = getDevice("33010602011187000001");
if (device instanceof FromDevice) {
clientFromDevice = (FromDevice) device;
return clientFromDevice;
}
clientFromDevice = createFromDevice(device);
return clientFromDevice;
}
@Override
public void setClientFromDevice(FromDevice fromDevice) {
if (fromDevice != null) {
this.clientFromDevice = fromDevice;
addOrUpdateDevice(fromDevice);
}
}
/**
* 获取客户端To设备
* 用于客户端接收响应的场景
*/
public ToDevice getClientToDevice() {
Device device = getDevice("41010500002000000001");
if (device instanceof ToDevice) {
return (ToDevice)device;
}
// 如果不是ToDevice类型，创建新的ToDevice
return createToDevice(device);
}
/**
* 获取服务端From设备
* 用于服务端主动发送请求的场景
*/
public FromDevice getServerFromDevice() {
Device device = getDevice("41010500002000000001");
if (device instanceof FromDevice) {
serverFromDevice = (FromDevice) device;
return serverFromDevice;
}
serverFromDevice = createFromDevice(device);
return serverFromDevice;
}
@Override
public void setServerFromDevice(FromDevice fromDevice) {
if (fromDevice != null) {
this.serverFromDevice = fromDevice;
addOrUpdateDevice(fromDevice);
}
}
/**
* 获取服务端To设备
* 用于服务端接收响应的场景
*/
public ToDevice getServerToDevice() {
Device device = getDevice("33010602011187000001");
if (device instanceof ToDevice) {
return (ToDevice)device;
}
// 如果不是ToDevice类型，创建新的ToDevice
return createToDevice(device);
}
/**
* 根据Device创建FromDevice
*/
public FromDevice createFromDevice(Device device) {
if (device == null) {
log.warn("设备为空，无法创建FromDevice");
return null;
}
FromDevice fromDevice = FromDevice.getInstance(device.getUserId(), device.getIp(), device.getPort());
fromDevice.setPassword(device.getPassword());
fromDevice.setRealm(device.getRealm());
fromDevice.setTransport(device.getTransport());
fromDevice.setStreamMode(device.getStreamMode());
fromDevice.setCharset(device.getCharset());
return fromDevice;
}
/**
* 根据Device创建ToDevice
*/
public ToDevice createToDevice(Device device) {
if (device == null) {
log.warn("设备为空，无法创建ToDevice");
return null;
}
ToDevice toDevice = ToDevice.getInstance(device.getUserId(), device.getIp(), device.getPort());
toDevice.setPassword(device.getPassword());
toDevice.setRealm(device.getRealm());
toDevice.setTransport(device.getTransport());
toDevice.setStreamMode(device.getStreamMode());
toDevice.setCharset(device.getCharset());
return toDevice;
}
/**
* 获取所有FromDevice类型的设备
*/
public List<FromDevice> getFromDevices() {
return userIdMap.values().stream()
.filter(device -> device instanceof FromDevice)
.map(device -> (FromDevice)device)
.collect(Collectors.toList());
}
/**
* 获取所有ToDevice类型的设备
*/
public List<ToDevice> getToDevices() {
return userIdMap.values().stream()
.filter(device -> device instanceof ToDevice)
.map(device -> (ToDevice)device)
.collect(Collectors.toList());
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestDeviceProperties.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestDeviceProperties.java | package io.github.lunasaw.gbproxy.test.config;
import io.github.lunasaw.gbproxy.client.config.SipClientProperties;
import io.github.lunasaw.gbproxy.server.config.SipServerProperties;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
/**
* @author weidian
*/
@Data
@Configuration
@ConfigurationProperties(prefix = "sip")
public class TestDeviceProperties {
private SipServerProperties server;
private SipClientProperties client;
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/SipProcessorConfiguration.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/SipProcessorConfiguration.java | package io.github.lunasaw.gbproxy.test.config;
import org.springframework.context.annotation.Configuration;
/**
* @author luna
* @date 2023/10/17
*/
@Configuration
public class SipProcessorConfiguration {
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestConfiguration.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/config/TestConfiguration.java | package io.github.lunasaw.gbproxy.test.config;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceOtherUpdateNotify;
import io.github.lunasaw.gb28181.common.entity.query.DeviceQuery;
import io.github.lunasaw.gb28181.common.entity.response.DeviceSubscribe;
import io.github.lunasaw.gbproxy.client.transmit.request.subscribe.SubscribeRequestHandler;
import io.github.lunasaw.gbproxy.client.transmit.response.register.RegisterProcessorHandler;
import io.github.lunasaw.gbproxy.server.transmit.request.notify.ServerNotifyProcessorHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.subscribe.SubscribeInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
import javax.sip.RequestEvent;
import javax.sip.ResponseEvent;
/**
* 测试专用配置类
* 用于简化测试环境，禁用复杂的组件，并提供测试专用的Bean实现
*
* @author luna
* @date 2025/01/23
*/
@Configuration
@Profile("test")
@EnableAutoConfiguration(exclude = {
// 排除可能导致问题的自动配置
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration.class,
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration.class,
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration.class,
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration.class
})
@Slf4j
public class TestConfiguration {
/**
* 测试专用的RegisterProcessorHandler实现
*/
@Bean
@Primary
public RegisterProcessorHandler testRegisterProcessorHandler() {
return new RegisterProcessorHandler() {
@Override
public void registerSuccess(String toUserId) {
log.info("🎉 Test RegisterProcessorHandler - 注册成功: toUserId={}", toUserId);
}
@Override
public void handleUnauthorized(ResponseEvent evt, String toUserId, String callId) {
log.info("🔐 Test RegisterProcessorHandler - 处理未授权: toUserId={}, callId={}", toUserId, callId);
}
@Override
public void handleRegisterFailure(String toUserId, int statusCode) {
log.info("❌ Test RegisterProcessorHandler - 注册失败: toUserId={}, statusCode={}", toUserId, statusCode);
}
};
}
/**
* 测试专用的SubscribeRequestHandler实现
*/
@Bean
@Primary
public SubscribeRequestHandler testSubscribeRequestHandler() {
return new SubscribeRequestHandler() {
@Override
public void putSubscribe(String userId, SubscribeInfo subscribeInfo) {
log.info("🔔 Test SubscribeRequestHandler - 添加订阅: userId={}, subscribeInfo={}", userId, subscribeInfo);
}
@Override
public DeviceSubscribe getDeviceSubscribe(DeviceQuery deviceQuery) {
log.info("📋 Test SubscribeRequestHandler - 获取设备订阅: deviceQuery={}", deviceQuery);
return new DeviceSubscribe();
}
};
}
/**
* 测试专用的ServerNotifyProcessorHandler实现
*/
@Bean
@Primary
public ServerNotifyProcessorHandler testServerNotifyProcessorHandler() {
return new ServerNotifyProcessorHandler() {
@Override
public void handleNotifyRequest(RequestEvent evt, FromDevice fromDevice) {
log.info("📢 Test ServerNotifyProcessorHandler - 处理NOTIFY请求: fromDevice={}", fromDevice);
}
@Override
public boolean validateDevicePermission(RequestEvent evt) {
log.info("🔒 Test ServerNotifyProcessorHandler - 验证设备权限: 默认允许");
return true;
}
@Override
public void handleNotifyError(RequestEvent evt, String errorMessage) {
log.info("⚠️ Test ServerNotifyProcessorHandler - 处理NOTIFY错误: {}", errorMessage);
}
@Override
public void deviceNotifyUpdate(String userId, DeviceOtherUpdateNotify deviceOtherUpdateNotify) {
log.info("🔄 Test ServerNotifyProcessorHandler - 设备更新通知: userId={}", userId);
}
};
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestServerMessageProcessorHandler.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestServerMessageProcessorHandler.java | package io.github.lunasaw.gbproxy.test.handler;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceAlarmNotify;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceKeepLiveNotify;
import io.github.lunasaw.gb28181.common.entity.notify.MediaStatusNotify;
import io.github.lunasaw.gb28181.common.entity.notify.MobilePositionNotify;
import io.github.lunasaw.gb28181.common.entity.response.DeviceInfo;
import io.github.lunasaw.gb28181.common.entity.response.DeviceRecord;
import io.github.lunasaw.gb28181.common.entity.response.DeviceResponse;
import io.github.lunasaw.gb28181.common.entity.response.DeviceConfigResponse;
import io.github.lunasaw.gbproxy.server.transmit.request.message.ServerMessageProcessorHandler;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.RemoteAddressInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/**
* 测试专用的ServerMessageProcessorHandler实现
* 用于验证MESSAGE请求的处理流程
*/
@Component
@Primary
@Slf4j
public class TestServerMessageProcessorHandler implements ServerMessageProcessorHandler {
// 静态字段用于测试验证
private static CountDownLatch keepaliveLatch;
private static AtomicBoolean keepaliveReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceKeepLiveNotify> receivedKeepalive = new AtomicReference<>();
// === 新增：报警 ===
private static CountDownLatch alarmLatch;
private static AtomicBoolean alarmReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceAlarmNotify> receivedAlarm = new AtomicReference<>();
// === 新增：目录 ===
private static CountDownLatch catalogLatch;
private static AtomicBoolean catalogReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceResponse> receivedCatalog = new AtomicReference<>();
// === 新增：设备信息 ===
private static CountDownLatch deviceInfoLatch;
private static AtomicBoolean deviceInfoReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceInfo> receivedDeviceInfo = new AtomicReference<>();
// === 新增：设备状态 ===
private static CountDownLatch deviceStatusLatch;
private static AtomicBoolean deviceStatusReceived = new AtomicBoolean(false);
private static AtomicReference<io.github.lunasaw.gb28181.common.entity.response.DeviceStatus> receivedDeviceStatus = new AtomicReference<>();
// === 新增：录像 ===
private static CountDownLatch deviceRecordLatch;
private static AtomicBoolean deviceRecordReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceRecord> receivedDeviceRecord = new AtomicReference<>();
// === 新增：设备配置 ===
private static CountDownLatch deviceConfigLatch;
private static AtomicBoolean deviceConfigReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceConfigResponse> receivedDeviceConfig = new AtomicReference<>();
// === 新增：Invite/Play 点播 ===
private static CountDownLatch invitePlayLatch;
private static AtomicBoolean invitePlayReceived = new AtomicBoolean(false);
private static AtomicReference<String> receivedInvitePlayCallId = new AtomicReference<>();
private static AtomicReference<String> receivedInvitePlaySdp = new AtomicReference<>();
private static AtomicReference<String> receivedInvitePlayFromUserId = new AtomicReference<>();
// === 新增：Invite/PlayBack 回放 ===
private static CountDownLatch invitePlayBackLatch;
private static AtomicBoolean invitePlayBackReceived = new AtomicBoolean(false);
private static AtomicReference<String> receivedInvitePlayBackCallId = new AtomicReference<>();
private static AtomicReference<String> receivedInvitePlayBackSdp = new AtomicReference<>();
private static AtomicReference<String> receivedInvitePlayBackFromUserId = new AtomicReference<>();
@Override
public void handleMessageRequest(RequestEvent evt, FromDevice fromDevice) {
log.info("🔄 TestServerMessageProcessorHandler 处理MESSAGE请求 - evt: {}, fromDevice: {}", evt, fromDevice);
// 调用消息处理流程，这会触发具体的MessageHandler
try {
// 这里应该调用父类的处理逻辑，但由于我们实现的是接口，需要手动触发
log.info("✅ TestServerMessageProcessorHandler MESSAGE请求处理完成");
} catch (Exception e) {
log.error("❌ TestServerMessageProcessorHandler MESSAGE请求处理异常", e);
}
}
@Override
public boolean validateDevicePermission(RequestEvent evt) {
log.info("✅ TestServerMessageProcessorHandler 验证设备权限通过");
return true;
}
@Override
public FromDevice getFromDevice() {
// 返回一个模拟的设备信息以便测试继续进行
FromDevice fromDevice = new FromDevice();
fromDevice.setUserId("33010602011187000001");
fromDevice.setIp("127.0.0.1");
fromDevice.setPort(5061);
fromDevice.setTransport("UDP");
log.info("🔧 TestServerMessageProcessorHandler 返回模拟设备信息: {}", fromDevice);
return fromDevice;
}
@Override
public void handleMessageError(RequestEvent evt, String errorMessage) {
log.error("❌ TestServerMessageProcessorHandler 处理错误: {}", errorMessage);
}
@Override
public void keepLiveDevice(DeviceKeepLiveNotify deviceKeepLiveNotify) {
log.info("💓 TestServerMessageProcessorHandler 接收到心跳: {}", deviceKeepLiveNotify);
recordKeepalive(deviceKeepLiveNotify);
}
@Override
public void updateRemoteAddress(String userId, RemoteAddressInfo remoteAddressInfo) {
log.info("📍 TestServerMessageProcessorHandler 更新设备地址: userId={}, address={}", userId, remoteAddressInfo);
}
@Override
public void updateDeviceAlarm(DeviceAlarmNotify deviceAlarmNotify) {
log.info("🚨 TestServerMessageProcessorHandler 更新设备报警: {}", deviceAlarmNotify);
alarmReceived.set(true);
receivedAlarm.set(deviceAlarmNotify);
if (alarmLatch != null) alarmLatch.countDown();
}
@Override
public void updateMobilePosition(MobilePositionNotify mobilePositionNotify) {
log.info("📱 TestServerMessageProcessorHandler 更新移动位置: {}", mobilePositionNotify);
}
@Override
public void updateMediaStatus(MediaStatusNotify mediaStatusNotify) {
log.info("📺 TestServerMessageProcessorHandler 更新媒体状态: {}", mediaStatusNotify);
}
@Override
public void updateDeviceRecord(String userId, DeviceRecord deviceRecord) {
log.info("📼 TestServerMessageProcessorHandler 更新设备录像: userId={}, record={}", userId, deviceRecord);
deviceRecordReceived.set(true);
receivedDeviceRecord.set(deviceRecord);
if (deviceRecordLatch != null) deviceRecordLatch.countDown();
}
@Override
public void updateDeviceResponse(String userId, DeviceResponse deviceResponse) {
log.info("📋 TestServerMessageProcessorHandler 更新设备响应: userId={}, response={}", userId, deviceResponse);
catalogReceived.set(true);
receivedCatalog.set(deviceResponse);
if (catalogLatch != null) catalogLatch.countDown();
}
@Override
public void updateDeviceInfo(String userId, DeviceInfo deviceInfo) {
log.info("ℹ️ TestServerMessageProcessorHandler 更新设备信息: userId={}, info={}", userId, deviceInfo);
deviceInfoReceived.set(true);
receivedDeviceInfo.set(deviceInfo);
if (deviceInfoLatch != null) deviceInfoLatch.countDown();
}
@Override
public void updateDeviceConfig(String userId, DeviceConfigResponse deviceConfigResponse) {
log.info("⚙️ TestServerMessageProcessorHandler 更新设备配置: userId={}, config={}", userId, deviceConfigResponse);
deviceConfigReceived.set(true);
receivedDeviceConfig.set(deviceConfigResponse);
if (deviceConfigLatch != null) deviceConfigLatch.countDown();
}
// 设备状态
public void updateDeviceStatus(String userId, io.github.lunasaw.gb28181.common.entity.response.DeviceStatus deviceStatus) {
log.info("📶 TestServerMessageProcessorHandler 更新设备状态: userId={}, status={}", userId, deviceStatus);
deviceStatusReceived.set(true);
receivedDeviceStatus.set(deviceStatus);
if (deviceStatusLatch != null) deviceStatusLatch.countDown();
}
// === 测试辅助方法 ===
public static void resetTestState() {
keepaliveLatch = new CountDownLatch(1);
keepaliveReceived.set(false);
receivedKeepalive.set(null);
alarmLatch = new CountDownLatch(1);
alarmReceived.set(false);
receivedAlarm.set(null);
catalogLatch = new CountDownLatch(1);
catalogReceived.set(false);
receivedCatalog.set(null);
deviceInfoLatch = new CountDownLatch(1);
deviceInfoReceived.set(false);
receivedDeviceInfo.set(null);
deviceStatusLatch = new CountDownLatch(1);
deviceStatusReceived.set(false);
receivedDeviceStatus.set(null);
deviceRecordLatch = new CountDownLatch(1);
deviceRecordReceived.set(false);
receivedDeviceRecord.set(null);
deviceConfigLatch = new CountDownLatch(1);
deviceConfigReceived.set(false);
receivedDeviceConfig.set(null);
invitePlayLatch = new CountDownLatch(1);
invitePlayReceived.set(false);
receivedInvitePlayCallId.set(null);
receivedInvitePlaySdp.set(null);
receivedInvitePlayFromUserId.set(null);
invitePlayBackLatch = new CountDownLatch(1);
invitePlayBackReceived.set(false);
receivedInvitePlayBackCallId.set(null);
receivedInvitePlayBackSdp.set(null);
receivedInvitePlayBackFromUserId.set(null);
log.info("🔄 TestServerMessageProcessorHandler 测试状态已重置");
}
/**
* 记录接收到的心跳
*/
private static void recordKeepalive(DeviceKeepLiveNotify keepalive) {
keepaliveReceived.set(true);
receivedKeepalive.set(keepalive);
if (keepaliveLatch != null) {
keepaliveLatch.countDown();
}
log.info("📝 已记录心跳: {}", keepalive);
}
/**
* 等待心跳接收
*/
public static boolean waitForKeepalive(long timeout, TimeUnit unit) throws InterruptedException {
if (keepaliveLatch == null) {
return false;
}
return keepaliveLatch.await(timeout, unit);
}
/**
* 检查是否接收到心跳
*/
public static boolean hasReceivedKeepalive() {
return keepaliveReceived.get();
}
/**
* 获取接收到的心跳
*/
public static DeviceKeepLiveNotify getReceivedKeepalive() {
return receivedKeepalive.get();
}
// === 报警 ===
public static boolean waitForAlarm(long timeout, TimeUnit unit) throws InterruptedException {
if (alarmLatch == null) return false;
return alarmLatch.await(timeout, unit);
}
public static boolean hasReceivedAlarm() {
return alarmReceived.get();
}
public static DeviceAlarmNotify getReceivedAlarm() {
return receivedAlarm.get();
}
// === 目录 ===
public static boolean waitForCatalog(long timeout, TimeUnit unit) throws InterruptedException {
if (catalogLatch == null) return false;
return catalogLatch.await(timeout, unit);
}
public static boolean hasReceivedCatalog() {
return catalogReceived.get();
}
public static DeviceResponse getReceivedCatalog() {
return receivedCatalog.get();
}
// === 设备信息 ===
public static boolean waitForDeviceInfo(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceInfoLatch == null) return false;
return deviceInfoLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceInfo() {
return deviceInfoReceived.get();
}
public static DeviceInfo getReceivedDeviceInfo() {
return receivedDeviceInfo.get();
}
// === 设备状态 ===
public static boolean waitForDeviceStatus(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceStatusLatch == null) return false;
return deviceStatusLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceStatus() {
return deviceStatusReceived.get();
}
public static io.github.lunasaw.gb28181.common.entity.response.DeviceStatus getReceivedDeviceStatus() {
return receivedDeviceStatus.get();
}
// === 录像 ===
public static boolean waitForDeviceRecord(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceRecordLatch == null) return false;
return deviceRecordLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceRecord() {
return deviceRecordReceived.get();
}
public static DeviceRecord getReceivedDeviceRecord() {
return receivedDeviceRecord.get();
}
// === 设备配置 ===
public static boolean waitForDeviceConfig(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceConfigLatch == null) return false;
return deviceConfigLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceConfig() {
return deviceConfigReceived.get();
}
public static DeviceConfigResponse getReceivedDeviceConfig() {
return receivedDeviceConfig.get();
}
// === Invite/Play 点播 ===
public static boolean waitForInvitePlay(long timeout, TimeUnit unit) throws InterruptedException {
if (invitePlayLatch == null) return false;
return invitePlayLatch.await(timeout, unit);
}
public static boolean hasReceivedInvitePlay() {
return invitePlayReceived.get();
}
public static String getReceivedInvitePlayCallId() {
return receivedInvitePlayCallId.get();
}
public static String getReceivedInvitePlaySdp() {
return receivedInvitePlaySdp.get();
}
public static String getReceivedInvitePlayFromUserId() {
return receivedInvitePlayFromUserId.get();
}
// === Invite/PlayBack 回放 ===
public static boolean waitForInvitePlayBack(long timeout, TimeUnit unit) throws InterruptedException {
if (invitePlayBackLatch == null) return false;
return invitePlayBackLatch.await(timeout, unit);
}
public static boolean hasReceivedInvitePlayBack() {
return invitePlayBackReceived.get();
}
public static String getReceivedInvitePlayBackCallId() {
return receivedInvitePlayBackCallId.get();
}
public static String getReceivedInvitePlayBackSdp() {
return receivedInvitePlayBackSdp.get();
}
public static String getReceivedInvitePlayBackFromUserId() {
return receivedInvitePlayBackFromUserId.get();
}
// === Invite/Play 点播更新方法 ===
public static void updateInvitePlay(String callId, String sdpContent, String fromUserId) {
log.info("📺 TestServerMessageProcessorHandler 更新实时点播: callId={}, fromUserId={}, sdp={}", callId, fromUserId, sdpContent);
invitePlayReceived.set(true);
receivedInvitePlayCallId.set(callId);
receivedInvitePlaySdp.set(sdpContent);
receivedInvitePlayFromUserId.set(fromUserId);
if (invitePlayLatch != null) invitePlayLatch.countDown();
}
public static void updateInvitePlayBack(String callId, String sdpContent, String fromUserId) {
log.info("📼 TestServerMessageProcessorHandler 更新回放点播: callId={}, fromUserId={}, sdp={}", callId, fromUserId, sdpContent);
invitePlayBackReceived.set(true);
receivedInvitePlayBackCallId.set(callId);
receivedInvitePlayBackSdp.set(sdpContent);
receivedInvitePlayBackFromUserId.set(fromUserId);
if (invitePlayBackLatch != null) invitePlayBackLatch.countDown();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestRegisterProcessorHandler.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestRegisterProcessorHandler.java | package io.github.lunasaw.gbproxy.test.handler;
import io.github.lunasaw.gbproxy.client.transmit.response.register.RegisterProcessorHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import javax.sip.ResponseEvent;
/**
* 测试专用的 RegisterProcessorHandler 实现
* 用于客户端注册响应处理的测试
*
* @author claude
* @date 2025/01/23
*/
@Component
@Primary
@Slf4j
public class TestRegisterProcessorHandler implements RegisterProcessorHandler {
@Override
public void registerSuccess(String toUserId) {
log.info("🎉 TestRegisterProcessorHandler - 注册成功: toUserId={}", toUserId);
}
@Override
public void handleUnauthorized(ResponseEvent evt, String toUserId, String callId) {
log.info("🔐 TestRegisterProcessorHandler - 处理未授权: toUserId={}, callId={}", toUserId, callId);
}
@Override
public void handleRegisterFailure(String toUserId, int statusCode) {
log.info("❌ TestRegisterProcessorHandler - 注册失败: toUserId={}, statusCode={}", toUserId, statusCode);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestClientMessageProcessorHandler.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestClientMessageProcessorHandler.java | package io.github.lunasaw.gbproxy.test.handler;
import com.luna.common.date.DateUtils;
import io.github.lunasaw.gb28181.common.entity.control.*;
import io.github.lunasaw.gb28181.common.entity.notify.*;
import io.github.lunasaw.gb28181.common.entity.query.*;
import io.github.lunasaw.gb28181.common.entity.response.*;
import io.github.lunasaw.gbproxy.client.transmit.request.message.MessageRequestHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/**
* 测试专用的Client消息处理器Handler
* 用于验证客户端MESSAGE请求的处理流程
*/
@Component
@Slf4j
public class TestClientMessageProcessorHandler implements MessageRequestHandler {
// === 测试辅助字段 ===
private static CountDownLatch keepaliveLatch;
private static AtomicBoolean keepaliveReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceKeepLiveNotify> receivedKeepalive = new AtomicReference<>();
private static CountDownLatch alarmLatch;
private static AtomicBoolean alarmReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceAlarmNotify> receivedAlarm = new AtomicReference<>();
private static CountDownLatch deviceStatusLatch;
private static AtomicBoolean deviceStatusReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceStatus> receivedDeviceStatus = new AtomicReference<>();
private static CountDownLatch deviceInfoLatch;
private static AtomicBoolean deviceInfoReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceInfo> receivedDeviceInfo = new AtomicReference<>();
private static CountDownLatch deviceRecordLatch;
private static AtomicBoolean deviceRecordReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceRecord> receivedDeviceRecord = new AtomicReference<>();
private static CountDownLatch deviceConfigLatch;
private static AtomicBoolean deviceConfigReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceConfigResponse> receivedDeviceConfig = new AtomicReference<>();
// === Catalog 目录 ===
private static CountDownLatch catalogLatch;
private static AtomicBoolean catalogReceived = new AtomicBoolean(false);
private static AtomicReference<DeviceResponse> receivedCatalog = new AtomicReference<>();
// === MobilePosition 移动位置 ===
private static CountDownLatch mobilePositionLatch;
private static AtomicBoolean mobilePositionReceived = new AtomicBoolean(false);
private static AtomicReference<MobilePositionNotify> receivedMobilePosition = new AtomicReference<>();
// === PresetQuery 预置位 ===
private static CountDownLatch presetQueryLatch;
private static AtomicBoolean presetQueryReceived = new AtomicBoolean(false);
private static AtomicReference<PresetQueryResponse> receivedPresetQuery = new AtomicReference<>();
// === 业务方法实现 ===
@Override
public DeviceRecord getDeviceRecord(DeviceRecordQuery deviceRecordQuery) {
log.info("[ClientTest] 获取设备录像信息: {}", deviceRecordQuery);
DeviceRecord deviceRecord = new DeviceRecord();
updateDeviceRecord(deviceRecord);
return receivedDeviceRecord.get();
}
@Override
public DeviceStatus getDeviceStatus(String userId) {
log.info("[ClientTest] 获取设备状态信息: {}", userId);
DeviceStatus deviceStatus = new DeviceStatus();
updateDeviceStatus(deviceStatus);
return receivedDeviceStatus.get();
}
@Override
public DeviceInfo getDeviceInfo(String userId) {
log.info("[ClientTest] 获取设备信息: {}", userId);
DeviceInfo deviceInfo = new DeviceInfo();
updateDeviceInfo(deviceInfo);
return receivedDeviceInfo.get();
}
@Override
public DeviceResponse getDeviceItem(String userId) {
log.info("[ClientTest] 获取设备通道信息: {}", userId);
DeviceResponse deviceResponse = new DeviceResponse();
updateCatalog(deviceResponse);
return receivedCatalog.get();
}
@Override
public void broadcastNotify(DeviceBroadcastNotify broadcastNotify) {
log.info("[ClientTest] 接收到语音广播通知: {}", broadcastNotify);
}
@Override
public DeviceAlarmNotify getDeviceAlarmNotify(DeviceAlarmQuery deviceAlarmQuery) {
log.info("[ClientTest] 获取设备告警通知: {}", deviceAlarmQuery);
DeviceAlarmNotify alarmNotify = new DeviceAlarmNotify();
updateDeviceAlarm(alarmNotify);
return receivedAlarm.get();
}
@Override
public DeviceConfigResponse getDeviceConfigResponse(DeviceConfigDownload deviceConfigDownload) {
log.info("[ClientTest] 获取设备配置响应: {}", deviceConfigDownload);
DeviceConfigResponse configResponse = new DeviceConfigResponse();
updateDeviceConfig(configResponse);
return receivedDeviceConfig.get();
}
@Override
public <T> void deviceControl(T deviceControlBase) {
log.info("[ClientTest] 处理设备控制命令: {}", deviceControlBase);
}
@Override
public PresetQueryResponse getDevicePresetQueryResponse(PresetQuery presetQuery) {
return null;
}
@Override
public PresetQueryResponse getPresetQueryResponse(String userId) {
log.info("[ClientTest] 获取设备预置位信息: {}", userId);
PresetQueryResponse response = new PresetQueryResponse();
updatePresetQuery(response);
return receivedPresetQuery.get();
}
public void updatePresetQuery(PresetQueryResponse response) {
log.info("[ClientTest] 更新设备预置位: {}", response);
presetQueryReceived.set(true);
receivedPresetQuery.set(response);
if (presetQueryLatch != null) presetQueryLatch.countDown();
}
public static boolean waitForPresetQuery(long timeout, TimeUnit unit) throws InterruptedException {
if (presetQueryLatch == null) return false;
return presetQueryLatch.await(timeout, unit);
}
public static boolean hasReceivedPresetQuery() {
return presetQueryReceived.get();
}
public static PresetQueryResponse getReceivedPresetQuery() {
return receivedPresetQuery.get();
}
@Override
public ConfigDownloadResponse getConfigDownloadResponse(String userId, String configType) {
log.info("[ClientTest] 获取设备配置查询应答: {}, configType={}", userId, configType);
ConfigDownloadResponse response = new ConfigDownloadResponse();
// 可根据需要填充模拟数据
// response.setBasicParam(...);
// 可添加辅助测试状态
return response;
}
@Override
public MobilePositionNotify getMobilePositionNotify(MobilePositionQuery mobilePositionQuery) {
// 模拟获取移动位置通知
MobilePositionNotify mobilePositionNotify = new MobilePositionNotify();
mobilePositionNotify.setCmdType("MobilePosition");
mobilePositionNotify.setSn(mobilePositionQuery.getSn());
mobilePositionNotify.setDeviceId(mobilePositionQuery.getDeviceId());
mobilePositionNotify.setLatitude(34.0522);
mobilePositionNotify.setLongitude(-118.2437);
mobilePositionNotify.setTime(DateUtils.formatDateTime(new Date()));
mobilePositionNotify.setSpeed(10.0);
log.info("[ClientTest] 获取设备移动位置通知: {}", mobilePositionQuery);
updateMobilePosition(mobilePositionNotify);
return mobilePositionNotify;
}
public void updateMobilePosition(MobilePositionNotify mobilePositionNotify) {
log.info("[ClientTest] 更新移动位置: {}", mobilePositionNotify);
mobilePositionReceived.set(true);
receivedMobilePosition.set(mobilePositionNotify);
if (mobilePositionLatch != null) mobilePositionLatch.countDown();
}
public void updateDeviceAlarm(DeviceAlarmNotify deviceAlarmNotify) {
log.info("[ClientTest] 更新设备报警: {}", deviceAlarmNotify);
alarmReceived.set(true);
receivedAlarm.set(deviceAlarmNotify);
if (alarmLatch != null) alarmLatch.countDown();
}
// === 设备状态 ===
public void updateDeviceStatus(DeviceStatus deviceStatus) {
log.info("[ClientTest] 更新设备状态: {}", deviceStatus);
deviceStatusReceived.set(true);
receivedDeviceStatus.set(deviceStatus);
if (deviceStatusLatch != null) deviceStatusLatch.countDown();
}
// === 设备信息 ===
public void updateDeviceInfo(DeviceInfo deviceInfo) {
log.info("[ClientTest] 更新设备信息: {}", deviceInfo);
deviceInfoReceived.set(true);
receivedDeviceInfo.set(deviceInfo);
if (deviceInfoLatch != null) deviceInfoLatch.countDown();
}
// === 设备录像 ===
public void updateDeviceRecord(DeviceRecord deviceRecord) {
log.info("[ClientTest] 更新设备录像: {}", deviceRecord);
deviceRecordReceived.set(true);
receivedDeviceRecord.set(deviceRecord);
if (deviceRecordLatch != null) deviceRecordLatch.countDown();
}
// === 设备配置 ===
public void updateDeviceConfig(DeviceConfigResponse deviceConfigResponse) {
log.info("[ClientTest] 更新设备配置: {}", deviceConfigResponse);
deviceConfigReceived.set(true);
receivedDeviceConfig.set(deviceConfigResponse);
if (deviceConfigLatch != null) deviceConfigLatch.countDown();
}
// === Catalog 目录 ===
public void updateCatalog(DeviceResponse catalog) {
log.info("[ClientTest] 更新设备目录: {}", catalog);
catalogReceived.set(true);
receivedCatalog.set(catalog);
if (catalogLatch != null) catalogLatch.countDown();
}
// === MobilePosition 移动位置 ===
public static boolean waitForMobilePosition(long timeout, TimeUnit unit) throws InterruptedException {
if (mobilePositionLatch == null) return false;
return mobilePositionLatch.await(timeout, unit);
}
public static boolean hasReceivedMobilePosition() {
return mobilePositionReceived.get();
}
public static MobilePositionNotify getReceivedMobilePosition() {
return receivedMobilePosition.get();
}
// === 测试辅助方法 ===
public static void resetTestState() {
keepaliveLatch = new CountDownLatch(1);
keepaliveReceived.set(false);
receivedKeepalive.set(null);
alarmLatch = new CountDownLatch(1);
alarmReceived.set(false);
receivedAlarm.set(null);
deviceStatusLatch = new CountDownLatch(1);
deviceStatusReceived.set(false);
receivedDeviceStatus.set(null);
deviceInfoLatch = new CountDownLatch(1);
deviceInfoReceived.set(false);
receivedDeviceInfo.set(null);
deviceRecordLatch = new CountDownLatch(1);
deviceRecordReceived.set(false);
receivedDeviceRecord.set(null);
deviceConfigLatch = new CountDownLatch(1);
deviceConfigReceived.set(false);
receivedDeviceConfig.set(null);
catalogLatch = new CountDownLatch(1);
catalogReceived.set(false);
receivedCatalog.set(null);
mobilePositionLatch = new CountDownLatch(1);
mobilePositionReceived.set(false);
receivedMobilePosition.set(null);
presetQueryLatch = new CountDownLatch(1);
presetQueryReceived.set(false);
receivedPresetQuery.set(null);
log.info("[ClientTest] 测试状态已重置");
}
// === 等待与断言方法 ===
public static boolean waitForKeepalive(long timeout, TimeUnit unit) throws InterruptedException {
if (keepaliveLatch == null) return false;
return keepaliveLatch.await(timeout, unit);
}
public static boolean hasReceivedKeepalive() {
return keepaliveReceived.get();
}
public static DeviceKeepLiveNotify getReceivedKeepalive() {
return receivedKeepalive.get();
}
public static boolean waitForAlarm(long timeout, TimeUnit unit) throws InterruptedException {
if (alarmLatch == null) return false;
return alarmLatch.await(timeout, unit);
}
public static boolean hasReceivedAlarm() {
return alarmReceived.get();
}
public static DeviceAlarmNotify getReceivedAlarm() {
return receivedAlarm.get();
}
public static boolean waitForDeviceStatus(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceStatusLatch == null) return false;
return deviceStatusLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceStatus() {
return deviceStatusReceived.get();
}
public static DeviceStatus getReceivedDeviceStatus() {
return receivedDeviceStatus.get();
}
public static boolean waitForDeviceInfo(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceInfoLatch == null) return false;
return deviceInfoLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceInfo() {
return deviceInfoReceived.get();
}
public static DeviceInfo getReceivedDeviceInfo() {
return receivedDeviceInfo.get();
}
public static boolean waitForDeviceRecord(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceRecordLatch == null) return false;
return deviceRecordLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceRecord() {
return deviceRecordReceived.get();
}
public static DeviceRecord getReceivedDeviceRecord() {
return receivedDeviceRecord.get();
}
public static boolean waitForDeviceConfig(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceConfigLatch == null) return false;
return deviceConfigLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceConfig() {
return deviceConfigReceived.get();
}
public static DeviceConfigResponse getReceivedDeviceConfig() {
return receivedDeviceConfig.get();
}
public static boolean waitForCatalog(long timeout, TimeUnit unit) throws InterruptedException {
if (catalogLatch == null) return false;
return catalogLatch.await(timeout, unit);
}
public static boolean hasReceivedCatalog() {
return catalogReceived.get();
}
public static DeviceResponse getReceivedCatalog() {
return receivedCatalog.get();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestServerRegisterProcessorHandler.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestServerRegisterProcessorHandler.java | package io.github.lunasaw.gbproxy.test.handler;
import io.github.lunasaw.gbproxy.server.transmit.request.register.RegisterInfo;
import io.github.lunasaw.gbproxy.server.transmit.request.register.ServerRegisterProcessorHandler;
import io.github.lunasaw.sip.common.entity.SipTransaction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/**
* 测试专用的ServerRegisterProcessorHandler实现
* 用于验证REGISTER请求的处理流程
*
* @author claude
* @date 2025/07/21
*/
@Component
@Primary
@Slf4j
public class TestServerRegisterProcessorHandler implements ServerRegisterProcessorHandler {
// 静态字段用于测试验证
private static CountDownLatch registerLatch;
private static AtomicBoolean registerReceived = new AtomicBoolean(false);
private static AtomicReference<String> registeredUserId = new AtomicReference<>();
private static AtomicReference<RegisterInfo> receivedRegisterInfo = new AtomicReference<>();
private static CountDownLatch unauthorizedLatch;
private static AtomicBoolean unauthorizedReceived = new AtomicBoolean(false);
private static AtomicReference<String> unauthorizedUserId = new AtomicReference<>();
private static CountDownLatch deviceOnlineLatch;
private static AtomicBoolean deviceOnlineReceived = new AtomicBoolean(false);
private static AtomicReference<String> onlineUserId = new AtomicReference<>();
private static CountDownLatch deviceOfflineLatch;
private static AtomicBoolean deviceOfflineReceived = new AtomicBoolean(false);
private static AtomicReference<String> offlineUserId = new AtomicReference<>();
@Override
public void handleUnauthorized(String userId, RequestEvent evt) {
log.info("🔐 TestServerRegisterProcessorHandler 处理401未授权: userId={}", userId);
unauthorizedReceived.set(true);
unauthorizedUserId.set(userId);
if (unauthorizedLatch != null) {
unauthorizedLatch.countDown();
}
}
@Override
public SipTransaction getDeviceTransaction(String userId) {
log.info("🔍 TestServerRegisterProcessorHandler 获取设备事务: userId={}", userId);
return null; // 测试中返回null表示没有现有事务
}
@Override
public void handleRegisterInfoUpdate(String userId, RegisterInfo registerInfo, RequestEvent evt) {
log.info("📝 TestServerRegisterProcessorHandler 更新注册信息: userId={}, registerInfo={}", userId, registerInfo);
registerReceived.set(true);
registeredUserId.set(userId);
receivedRegisterInfo.set(registerInfo);
if (registerLatch != null) {
registerLatch.countDown();
}
}
@Override
public void handleDeviceOnline(String userId, SipTransaction sipTransaction, RequestEvent evt) {
log.info("🟢 TestServerRegisterProcessorHandler 设备上线: userId={}", userId);
deviceOnlineReceived.set(true);
onlineUserId.set(userId);
if (deviceOnlineLatch != null) {
deviceOnlineLatch.countDown();
}
}
@Override
public void handleDeviceOffline(String userId, RegisterInfo registerInfo, SipTransaction sipTransaction, RequestEvent evt) {
log.info("🔴 TestServerRegisterProcessorHandler 设备下线: userId={}", userId);
deviceOfflineReceived.set(true);
offlineUserId.set(userId);
if (deviceOfflineLatch != null) {
deviceOfflineLatch.countDown();
}
}
@Override
public Integer getDeviceExpire(String userId) {
log.info("⏰ TestServerRegisterProcessorHandler 获取设备过期时间: userId={}", userId);
return 3600; // 1小时
}
@Override
public boolean validatePassword(String userId, String password, RequestEvent evt) {
log.info("🔓 TestServerRegisterProcessorHandler 验证密码: userId={}, password={}", userId, password);
return true; // 测试中总是返回验证成功
}
// ==================== 测试工具方法 ====================
/**
* 重置测试状态
*/
public static void resetTestState() {
registerLatch = new CountDownLatch(1);
registerReceived.set(false);
registeredUserId.set(null);
receivedRegisterInfo.set(null);
unauthorizedLatch = new CountDownLatch(1);
unauthorizedReceived.set(false);
unauthorizedUserId.set(null);
deviceOnlineLatch = new CountDownLatch(1);
deviceOnlineReceived.set(false);
onlineUserId.set(null);
deviceOfflineLatch = new CountDownLatch(1);
deviceOfflineReceived.set(false);
offlineUserId.set(null);
log.info("🔄 TestServerRegisterProcessorHandler 测试状态已重置");
}
// === 注册相关 ===
public static boolean waitForRegister(long timeout, TimeUnit unit) throws InterruptedException {
if (registerLatch == null) return false;
return registerLatch.await(timeout, unit);
}
public static boolean hasReceivedRegister() {
return registerReceived.get();
}
public static String getRegisteredUserId() {
return registeredUserId.get();
}
public static RegisterInfo getReceivedRegisterInfo() {
return receivedRegisterInfo.get();
}
// === 401未授权相关 ===
public static boolean waitForUnauthorized(long timeout, TimeUnit unit) throws InterruptedException {
if (unauthorizedLatch == null) return false;
return unauthorizedLatch.await(timeout, unit);
}
public static boolean hasReceivedUnauthorized() {
return unauthorizedReceived.get();
}
public static String getUnauthorizedUserId() {
return unauthorizedUserId.get();
}
// === 设备上线相关 ===
public static boolean waitForDeviceOnline(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceOnlineLatch == null) return false;
return deviceOnlineLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceOnline() {
return deviceOnlineReceived.get();
}
public static String getOnlineUserId() {
return onlineUserId.get();
}
// === 设备下线相关 ===
public static boolean waitForDeviceOffline(long timeout, TimeUnit unit) throws InterruptedException {
if (deviceOfflineLatch == null) return false;
return deviceOfflineLatch.await(timeout, unit);
}
public static boolean hasReceivedDeviceOffline() {
return deviceOfflineReceived.get();
}
public static String getOfflineUserId() {
return offlineUserId.get();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestDeviceControlRequestHandler.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestDeviceControlRequestHandler.java | package io.github.lunasaw.gbproxy.test.handler;
import io.github.lunasaw.gb28181.common.entity.control.*;
import io.github.lunasaw.gbproxy.client.transmit.request.message.handler.control.DeviceControlRequestHandler;
import org.springframework.stereotype.Component;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* 用于端到端测试DeviceControl命令的测试Handler，支持各类命令的回调、同步和断言
*/
@Component
public class TestDeviceControlRequestHandler implements DeviceControlRequestHandler {
// PTZ
private static CountDownLatch ptzLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlPtz> ptzCmdRef = new AtomicReference<>();
// Guard
private static CountDownLatch guardLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlGuard> guardCmdRef = new AtomicReference<>();
// Alarm
private static CountDownLatch alarmLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlAlarm> alarmCmdRef = new AtomicReference<>();
// TeleBoot
private static CountDownLatch teleBootLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlTeleBoot> teleBootCmdRef = new AtomicReference<>();
// RecordCmd
private static CountDownLatch recordLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlRecordCmd> recordCmdRef = new AtomicReference<>();
// IFame
private static CountDownLatch iFameLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlIFame> iFameCmdRef = new AtomicReference<>();
// DragIn
private static CountDownLatch dragInLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlDragIn> dragInCmdRef = new AtomicReference<>();
// DragOut
private static CountDownLatch dragOutLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlDragOut> dragOutCmdRef = new AtomicReference<>();
// HomePosition
private static CountDownLatch homePositionLatch = new CountDownLatch(1);
private static final AtomicReference<DeviceControlPosition> homePositionCmdRef = new AtomicReference<>();
// Handler实现
@Override
public void handlePtzCmd(DeviceControlPtz ptzCmd) {
ptzCmdRef.set(ptzCmd);
ptzLatch.countDown();
}
@Override
public void handleGuardCmd(DeviceControlGuard guardCmd) {
guardCmdRef.set(guardCmd);
guardLatch.countDown();
}
@Override
public void handleAlarmCmd(DeviceControlAlarm alarmCmd) {
alarmCmdRef.set(alarmCmd);
alarmLatch.countDown();
}
@Override
public void handleTeleBoot(DeviceControlTeleBoot teleBootCmd) {
teleBootCmdRef.set(teleBootCmd);
teleBootLatch.countDown();
}
@Override
public void handleRecordCmd(DeviceControlRecordCmd recordCmd) {
recordCmdRef.set(recordCmd);
recordLatch.countDown();
}
@Override
public void handleIFameCmd(DeviceControlIFame iFameCmd) {
iFameCmdRef.set(iFameCmd);
iFameLatch.countDown();
}
@Override
public void handleDragZoomIn(DeviceControlDragIn dragInCmd) {
dragInCmdRef.set(dragInCmd);
dragInLatch.countDown();
}
@Override
public void handleDragZoomOut(DeviceControlDragOut dragOutCmd) {
dragOutCmdRef.set(dragOutCmd);
dragOutLatch.countDown();
}
@Override
public void handleHomePosition(DeviceControlPosition homePositionCmd) {
homePositionCmdRef.set(homePositionCmd);
homePositionLatch.countDown();
}
// reset方法
public static void resetTestState() {
ptzLatch = new CountDownLatch(1);
guardLatch = new CountDownLatch(1);
alarmLatch = new CountDownLatch(1);
teleBootLatch = new CountDownLatch(1);
recordLatch = new CountDownLatch(1);
iFameLatch = new CountDownLatch(1);
dragInLatch = new CountDownLatch(1);
dragOutLatch = new CountDownLatch(1);
homePositionLatch = new CountDownLatch(1);
ptzCmdRef.set(null);
guardCmdRef.set(null);
alarmCmdRef.set(null);
teleBootCmdRef.set(null);
recordCmdRef.set(null);
iFameCmdRef.set(null);
dragInCmdRef.set(null);
dragOutCmdRef.set(null);
homePositionCmdRef.set(null);
}
// 等待和断言方法（以PTZ为例，其他类似）
public static boolean waitForPtz(long timeout, TimeUnit unit) throws InterruptedException {
return ptzLatch.await(timeout, unit);
}
public static boolean hasReceivedPtz() {
return ptzCmdRef.get() != null;
}
public static DeviceControlPtz getReceivedPtz() {
return ptzCmdRef.get();
}
public static boolean waitForGuard(long timeout, TimeUnit unit) throws InterruptedException {
return guardLatch.await(timeout, unit);
}
public static boolean hasReceivedGuard() {
return guardCmdRef.get() != null;
}
public static DeviceControlGuard getReceivedGuard() {
return guardCmdRef.get();
}
public static boolean waitForAlarm(long timeout, TimeUnit unit) throws InterruptedException {
return alarmLatch.await(timeout, unit);
}
public static boolean hasReceivedAlarm() {
return alarmCmdRef.get() != null;
}
public static DeviceControlAlarm getReceivedAlarm() {
return alarmCmdRef.get();
}
public static boolean waitForTeleBoot(long timeout, TimeUnit unit) throws InterruptedException {
return teleBootLatch.await(timeout, unit);
}
public static boolean hasReceivedTeleBoot() {
return teleBootCmdRef.get() != null;
}
public static DeviceControlTeleBoot getReceivedTeleBoot() {
return teleBootCmdRef.get();
}
public static boolean waitForRecord(long timeout, TimeUnit unit) throws InterruptedException {
return recordLatch.await(timeout, unit);
}
public static boolean hasReceivedRecord() {
return recordCmdRef.get() != null;
}
public static DeviceControlRecordCmd getReceivedRecord() {
return recordCmdRef.get();
}
public static boolean waitForIFame(long timeout, TimeUnit unit) throws InterruptedException {
return iFameLatch.await(timeout, unit);
}
public static boolean hasReceivedIFame() {
return iFameCmdRef.get() != null;
}
public static DeviceControlIFame getReceivedIFame() {
return iFameCmdRef.get();
}
public static boolean waitForDragIn(long timeout, TimeUnit unit) throws InterruptedException {
return dragInLatch.await(timeout, unit);
}
public static boolean hasReceivedDragIn() {
return dragInCmdRef.get() != null;
}
public static DeviceControlDragIn getReceivedDragIn() {
return dragInCmdRef.get();
}
public static boolean waitForDragOut(long timeout, TimeUnit unit) throws InterruptedException {
return dragOutLatch.await(timeout, unit);
}
public static boolean hasReceivedDragOut() {
return dragOutCmdRef.get() != null;
}
public static DeviceControlDragOut getReceivedDragOut() {
return dragOutCmdRef.get();
}
public static boolean waitForHomePosition(long timeout, TimeUnit unit) throws InterruptedException {
return homePositionLatch.await(timeout, unit);
}
public static boolean hasReceivedHomePosition() {
return homePositionCmdRef.get() != null;
}
public static DeviceControlPosition getReceivedHomePosition() {
return homePositionCmdRef.get();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestServerInviteRequestHandler.java | gb28181-test/src/main/java/io/github/lunasaw/gbproxy/test/handler/TestServerInviteRequestHandler.java | package io.github.lunasaw.gbproxy.test.handler;
import io.github.lunasaw.gbproxy.server.transmit.request.invite.ServerInviteRequestHandler;
import io.github.lunasaw.sip.common.entity.SdpSessionDescription;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/**
* 测试专用的InviteRequestHandler实现
* 用于验证INVITE请求的处理流程和测试钩子
*/
@Component
@Primary
@Slf4j
public class TestServerInviteRequestHandler implements ServerInviteRequestHandler {
// === 测试辅助字段 ===
private static CountDownLatch invitePlayLatch;
private static AtomicBoolean invitePlayReceived = new AtomicBoolean(false);
private static AtomicReference<String> receivedInvitePlayCallId = new AtomicReference<>();
private static AtomicReference<String> receivedInvitePlaySdp = new AtomicReference<>();
private static CountDownLatch invitePlayBackLatch;
private static AtomicBoolean invitePlayBackReceived = new AtomicBoolean(false);
private static AtomicReference<String> receivedInvitePlayBackCallId = new AtomicReference<>();
private static AtomicReference<String> receivedInvitePlayBackSdp = new AtomicReference<>();
@Override
public void inviteSession(String callId, SdpSessionDescription sessionDescription) {
log.info("[ClientTest] 处理INVITE会话: callId={}, sessionDescription={}", callId, sessionDescription);
// 从sessionDescription中获取原始SDP内容
String sdpContent = null;
try {
if (sessionDescription != null && sessionDescription.getBaseSdb() != null) {
sdpContent = sessionDescription.getBaseSdb().toString();
}
} catch (Exception e) {
log.warn("获取SDP原始内容失败: callId={}", callId, e);
}
// 如果获取不到SDP内容，使用toString()的结果
if (sdpContent == null) {
sdpContent = sessionDescription != null ? sessionDescription.toString() : "";
}
updateTestHook(callId, sdpContent, sessionDescription);
}
@Override
public String getInviteResponse(String userId, SdpSessionDescription sessionDescription) {
log.info("[ClientTest] 获取INVITE响应: userId={}, sessionDescription={}", userId, sessionDescription);
// 返回一个简单的SDP响应内容用于测试
return "v=0\r\n" +
"o=" + userId + " 0 0 IN IP4 127.0.0.1\r\n" +
"s=Play\r\n" +
"c=IN IP4 127.0.0.1\r\n" +
"t=0 0\r\n" +
"m=video 6000 RTP/AVP 96\r\n" +
"a=rtpmap:96 PS/90000\r\n";
}
/**
* 更新测试钩子状态
*/
private void updateTestHook(String callId, String sdpContent, SdpSessionDescription sessionDescription) {
try {
log.info("📋 分析SDP内容: callId={}, sdpContent={}, sessionDescription={}", callId, sdpContent, sessionDescription);
// 根据SDP内容判断是实时点播还是回放点播
if (sdpContent.contains("s=PlayBack")) {
// 回放点播
updateInvitePlayBack(callId, sdpContent);
log.info("📼 更新回放点播测试钩子: callId={}", callId);
} else if (sdpContent.contains("s=Play")) {
// 实时点播
updateInvitePlay(callId, sdpContent);
log.info("📺 更新实时点播测试钩子: callId={}", callId);
} else {
// 其他类型的Invite请求
log.info("📺 收到其他类型INVITE请求: callId={}, sdp={}", callId, sessionDescription);
}
} catch (Exception e) {
log.warn("更新测试钩子时发生异常: callId={}", callId, e);
}
}
// === 实时点播测试钩子 ===
public void updateInvitePlay(String callId, String sdpContent) {
log.info("[ClientTest] 更新实时点播: callId={}", callId);
invitePlayReceived.set(true);
receivedInvitePlayCallId.set(callId);
receivedInvitePlaySdp.set(sdpContent);
if (invitePlayLatch != null) invitePlayLatch.countDown();
}
public static void resetInvitePlayTestState() {
invitePlayLatch = new CountDownLatch(1);
invitePlayReceived.set(false);
receivedInvitePlayCallId.set(null);
receivedInvitePlaySdp.set(null);
}
public static boolean waitForInvitePlay(long timeout, TimeUnit unit) throws InterruptedException {
if (invitePlayLatch == null) return false;
return invitePlayLatch.await(timeout, unit);
}
public static boolean hasReceivedInvitePlay() {
return invitePlayReceived.get();
}
public static String getReceivedInvitePlayCallId() {
return receivedInvitePlayCallId.get();
}
public static String getReceivedInvitePlaySdp() {
return receivedInvitePlaySdp.get();
}
// === 回放点播测试钩子 ===
public void updateInvitePlayBack(String callId, String sdpContent) {
log.info("[ClientTest] 更新回放点播: callId={}", callId);
invitePlayBackReceived.set(true);
receivedInvitePlayBackCallId.set(callId);
receivedInvitePlayBackSdp.set(sdpContent);
if (invitePlayBackLatch != null) invitePlayBackLatch.countDown();
}
public static void resetInvitePlayBackTestState() {
invitePlayBackLatch = new CountDownLatch(1);
invitePlayBackReceived.set(false);
receivedInvitePlayBackCallId.set(null);
receivedInvitePlayBackSdp.set(null);
}
public static boolean waitForInvitePlayBack(long timeout, TimeUnit unit) throws InterruptedException {
if (invitePlayBackLatch == null) return false;
return invitePlayBackLatch.await(timeout, unit);
}
public static boolean hasReceivedInvitePlayBack() {
return invitePlayBackReceived.get();
}
public static String getReceivedInvitePlayBackCallId() {
return receivedInvitePlayBackCallId.get();
}
public static String getReceivedInvitePlayBackSdp() {
return receivedInvitePlayBackSdp.get();
}
// === 重置所有测试状态 ===
public static void resetTestState() {
resetInvitePlayTestState();
resetInvitePlayBackTestState();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/test/java/io/github/lunasw/gbproxy/client/test/Gb28181ClientTest.java | gb28181-client/src/test/java/io/github/lunasw/gbproxy/client/test/Gb28181ClientTest.java | package io.github.lunasw.gbproxy.client.test;
import io.github.lunasaw.gbproxy.client.Gb28181Client;
import lombok.SneakyThrows;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.ResourceUtils;
import java.io.File;
import java.nio.file.Files;
import java.util.List;
/**
* @author luna
* @date 2023/10/12
*/
@SpringBootTest(classes = Gb28181Client.class)
public class Gb28181ClientTest {
@Test
public void atest() throws Exception {
File file = ResourceUtils.getFile("classpath:device/catalog.xml");
List<String> catalogList = Files.readAllLines(file.toPath());
StringBuffer catalogXml = new StringBuffer();
String sn = "34020000002000000001";
String deviceId = "34020000001320000001";
for (String xml : catalogList) {
catalogXml.append(xml.replaceAll("\\$\\{SN\\}", sn).replaceAll("\\$\\{DEVICE_ID\\}", deviceId)).append("\r\n");
}
System.out.println(catalogXml.toString());
}
@Test
public void btest() throws Exception {
SAXReader reader = new SAXReader();
File file = ResourceUtils.getFile("classpath:device/catalog.xml");
Document document = reader.read(file);
Element root = document.getRootElement();
// Item item = new Item();
// item.setDeviceId(root.elementText("DeviceID"));
// item.setName(root.elementText("Name"));
// item.setManufacturer(root.elementText("Manufacturer"));
QName qName = root.getQName();
System.out.println(qName);
Element cmdType = root.element("CmdType");
System.out.println(cmdType.getText());
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter(System.out, format);
writer.write( document );
// Compact format to System.out
format = OutputFormat.createCompactFormat();
writer = new XMLWriter(System.out, format);
writer.write(document);
writer.close();
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/test/java/io/github/lunasw/gbproxy/client/test/cmd/ApplicationTest.java | gb28181-client/src/test/java/io/github/lunasw/gbproxy/client/test/cmd/ApplicationTest.java | package io.github.lunasw.gbproxy.client.test.cmd;
import io.github.lunasaw.sip.common.transmit.CustomerSipListener;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import io.github.lunasaw.gbproxy.client.Gb28181Client;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.layer.SipLayer;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.transmit.event.Event;
import io.github.lunasaw.sip.common.transmit.event.EventResult;
import io.github.lunasaw.sip.common.utils.SipRequestUtils;
import lombok.SneakyThrows;
/**
* @author luna
* @date 2023/10/13
*/
@SpringBootTest(classes = Gb28181Client.class)
public class ApplicationTest {
static String localIp = "172.19.128.100";
FromDevice fromDevice;
ToDevice toDevice;
@Autowired
SipLayer sipLayer;
@BeforeEach
public void before() {
sipLayer.addListeningPoint(localIp, 8117);
fromDevice = FromDevice.getInstance("33010602011187000001", localIp, 8117);
toDevice = ToDevice.getInstance("41010500002000000001", localIp, 8118);
toDevice.setPassword("luna");
toDevice.setRealm("4101050000");
}
@SneakyThrows
@Test
public void atest() {
String resultCallId = ClientCommandSender.sendCommand("MESSAGE", fromDevice, toDevice, "123123");
System.out.println("MESSAGE请求发送成功，CallId: " + resultCallId);
}
@SneakyThrows
@Test
public void register() {
String resultCallId = ClientCommandSender.sendRegisterCommand(fromDevice, toDevice, 300);
System.out.println("REGISTER请求发送成功，CallId: " + resultCallId);
}
@SneakyThrows
@Test
public void registerResponse() {
}
@AfterEach
public void after() {
while (true) {
}
}
@Test
public void demo() {
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/Gb28181Client.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/Gb28181Client.java | package io.github.lunasaw.gbproxy.client;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
/**
* @author luna
* @date 2023/10/11
*/
@SpringBootApplication
public class Gb28181Client {
public static void main(String[] args) {
SpringApplication.run(Gb28181Client.class, args);
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/service/DefaultClientDeviceSupplier.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/service/DefaultClientDeviceSupplier.java | package io.github.lunasaw.gbproxy.client.service;
import io.github.lunasaw.gbproxy.client.config.SipClientProperties;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Service;
import java.util.concurrent.ConcurrentHashMap;
/**
* 客户端设备提供器默认实现
* 基于SipClientProperties配置的客户端设备管理
* <p>
* 设计原则：
* 1. 线程安全的设备管理
* 2. 基于配置的客户端设备初始化
* 3. 支持动态设备添加和移除
* 4. 自动生成客户端发送方设备信息
*
* @author luna
* @date 2025/8/2
*/
@Slf4j
@Service
@ConditionalOnMissingBean(ClientDeviceSupplier.class)
public class DefaultClientDeviceSupplier implements ClientDeviceSupplier {
/**
* 设备存储容器 - 线程安全
*/
private final ConcurrentHashMap<String, Device> deviceMap = new ConcurrentHashMap<>();
/**
* 客户端发送方设备信息
*/
private FromDevice clientFromDevice;
/**
* GB28181客户端配置属性
*/
@Autowired
private SipClientProperties clientProperties;
/**
* 初始化客户端发送方设备信息
*/
public DefaultClientDeviceSupplier() {
// 构造函数中不进行初始化，等待配置注入后再初始化
}
/**
* 初始化客户端发送方设备信息
* 基于配置属性创建客户端设备
*/
public void initializeClientFromDevice() {
if (clientProperties != null) {
this.clientFromDevice = FromDevice.getInstance(
clientProperties.getClientId(),
clientProperties.getDomain(),
clientProperties.getPort()
);
log.info("客户端发送方设备初始化完成: {}", clientFromDevice.getUserId());
} else {
log.warn("SipClientProperties未注入，使用默认客户端设备配置");
this.clientFromDevice = FromDevice.getInstance(
"34020000001320000001",
"127.0.0.1",
5061
);
}
}
@Override
public Device getDevice(String userId) {
if (userId == null) {
log.warn("获取设备时userId为空");
return null;
}
Device device = deviceMap.get(userId);
if (device == null) {
log.debug("未找到设备: {}", userId);
}
return device;
}
@Override
public FromDevice getClientFromDevice() {
// 延迟初始化，确保配置已注入
if (clientFromDevice == null) {
initializeClientFromDevice();
}
return clientFromDevice;
}
@Override
public void setClientFromDevice(FromDevice fromDevice) {
this.clientFromDevice = fromDevice;
log.info("客户端发送方设备设置成功: {}", fromDevice != null ? fromDevice.getUserId() : "null");
}
@Override
public String getName() {
return "DefaultClientDeviceSupplier";
}
/**
* 清空所有设备
*/
public void clearAllDevices() {
int count = deviceMap.size();
deviceMap.clear();
log.info("清空所有设备，共移除 {} 个设备", count);
}
/**
* 检查设备是否存在
*
* @param userId 用户ID
* @return 是否存在
*/
public boolean containsDevice(String userId) {
return userId != null && deviceMap.containsKey(userId);
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/ClientCommandSender.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/ClientCommandSender.java | package io.github.lunasaw.gbproxy.client.transmit.cmd;
import com.luna.common.check.Assert;
import com.luna.common.text.RandomStrUtil;
import io.github.lunasaw.gb28181.common.entity.DeviceAlarm;
import io.github.lunasaw.gb28181.common.entity.notify.*;
import io.github.lunasaw.gb28181.common.entity.response.DeviceResponse;
import io.github.lunasaw.gb28181.common.entity.response.DeviceItem;
import io.github.lunasaw.gb28181.common.entity.response.DeviceInfo;
import io.github.lunasaw.gb28181.common.entity.response.DeviceStatus;
import io.github.lunasaw.gb28181.common.entity.response.DeviceRecord;
import io.github.lunasaw.gb28181.common.entity.response.DeviceConfigResponse;
import io.github.lunasaw.gb28181.common.entity.response.PresetQueryResponse;
import io.github.lunasaw.gb28181.common.entity.response.ConfigDownloadResponse;
import io.github.lunasaw.gb28181.common.entity.enums.CmdTypeEnum;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.subscribe.SubscribeInfo;
import io.github.lunasaw.sip.common.transmit.event.Event;
import io.github.lunasaw.sip.common.context.SipTransactionContext;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.ClientCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.ClientCommandStrategyFactory;
import javax.sip.RequestEvent;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
/**
* GB28181客户端命令发送器
* 使用策略模式和建造者模式，提供更灵活和可扩展的命令发送接口
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class ClientCommandSender {
// ==================== 策略模式命令发送 ====================
/**
* 使用策略模式发送命令
*
* @param commandType 命令类型
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param params 命令参数
* @return callId
*/
public static String sendCommand(String commandType, FromDevice fromDevice, ToDevice toDevice, Object... params) {
// 如果没有对应的策略，使用MESSAGE策略
ClientCommandStrategy strategy;
try {
strategy = ClientCommandStrategyFactory.getStrategy(commandType);
} catch (IllegalArgumentException e) {
// 对于非SIP基础协议的命令，使用MESSAGE策略
strategy = ClientCommandStrategyFactory.getMessageStrategy();
}
return strategy.execute(fromDevice, toDevice, params);
}
/**
* 使用策略模式发送命令（支持事务上下文）
* 通过RequestEvent复用原请求的Call-ID，确保事务一致性
*
* @param commandType 命令类型
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param requestEvent 原始请求事件，用于复用Call-ID
* @param params 命令参数
* @return callId
*/
public static String sendCommand(String commandType, FromDevice fromDevice, ToDevice toDevice,
RequestEvent requestEvent, Object... params) {
try {
// 设置事务上下文（显式模式）
SipTransactionContext.setRequestEvent(requestEvent);
// 执行命令发送
return sendCommand(commandType, fromDevice, toDevice, params);
} finally {
// 清理事务上下文，避免内存泄漏
SipTransactionContext.clear();
}
}
/**
* 使用策略模式发送命令（带事件）
*
* @param commandType 命令类型
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param errorEvent 错误事件
* @param okEvent 成功事件
* @param params 命令参数
* @return callId
*/
public static String sendCommand(String commandType, FromDevice fromDevice, ToDevice toDevice, Event errorEvent, Event okEvent,
Object... params) {
// 如果没有对应的策略，使用MESSAGE策略
ClientCommandStrategy strategy;
try {
strategy = ClientCommandStrategyFactory.getStrategy(commandType);
} catch (IllegalArgumentException e) {
// 对于非SIP基础协议的命令，使用MESSAGE策略
strategy = ClientCommandStrategyFactory.getMessageStrategy();
}
return strategy.execute(fromDevice, toDevice, errorEvent, okEvent, params);
}
// ==================== 告警相关命令 ====================
/**
* 发送告警命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceAlarm 告警信息
* @return callId
*/
public static String sendAlarmCommand(FromDevice fromDevice, ToDevice toDevice, DeviceAlarm deviceAlarm) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceAlarm);
}
/**
* 发送告警命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceAlarmNotify 告警通知对象
* @return callId
*/
public static String sendAlarmCommand(FromDevice fromDevice, ToDevice toDevice, DeviceAlarmNotify deviceAlarmNotify) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceAlarmNotify);
}
// ==================== 心跳相关命令 ====================
/**
* 发送心跳命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param status 状态信息
* @return callId
*/
public static String sendKeepaliveCommand(FromDevice fromDevice, ToDevice toDevice, String status) {
DeviceKeepLiveNotify keepLiveNotify = new DeviceKeepLiveNotify(
CmdTypeEnum.KEEPALIVE.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
keepLiveNotify.setStatus(status);
return sendKeepaliveCommand(fromDevice, toDevice, keepLiveNotify);
}
public static String sendKeepaliveCommand(FromDevice fromDevice, ToDevice toDevice, DeviceKeepLiveNotify deviceKeepLiveNotify) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceKeepLiveNotify);
}
// ==================== 设备目录相关命令 ====================
/**
* 发送目录命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceResponse 设备响应对象
* @return callId
*/
public static String sendCatalogCommand(FromDevice fromDevice, ToDevice toDevice, DeviceResponse deviceResponse) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceResponse);
}
/**
* 发送目录命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 设备列表
* @return callId
*/
public static String sendCatalogCommand(FromDevice fromDevice, ToDevice toDevice, List<DeviceItem> deviceItems) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceItems);
}
/**
* 发送目录命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItem 单个设备项
* @return callId
*/
public static String sendCatalogCommand(FromDevice fromDevice, ToDevice toDevice, DeviceItem deviceItem) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceItem);
}
// ==================== 设备信息相关命令 ====================
/**
* 发送设备信息响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceInfo 设备信息
* @return callId
*/
public static String sendDeviceInfoCommand(FromDevice fromDevice, ToDevice toDevice, DeviceInfo deviceInfo) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceInfo);
}
/**
* 发送设备信息响应命令（支持事务上下文）
* 通过RequestEvent复用原请求的Call-ID，确保事务一致性
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceInfo 设备信息
* @param requestEvent 原始请求事件，用于复用Call-ID
* @return callId
*/
public static String sendDeviceInfoCommand(FromDevice fromDevice, ToDevice toDevice,
DeviceInfo deviceInfo, RequestEvent requestEvent) {
return sendCommand("MESSAGE", fromDevice, toDevice, requestEvent, deviceInfo);
}
/**
* 发送设备状态响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param online 在线状态 "ONLINE":"OFFLINE"
* @return callId
*/
public static String sendDeviceStatusCommand(FromDevice fromDevice, ToDevice toDevice, String online) {
DeviceStatus deviceStatus = new DeviceStatus(
CmdTypeEnum.DEVICE_STATUS.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceStatus.setOnline(online);
return sendDeviceStatusCommand(fromDevice, toDevice, deviceStatus);
}
/**
* 发送设备状态响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceStatus 在线状态 "ONLINE":"OFFLINE"
* @return callId
*/
public static String sendDeviceStatusCommand(FromDevice fromDevice, ToDevice toDevice, DeviceStatus deviceStatus) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceStatus);
}
// ==================== 位置信息相关命令 ====================
/**
* 发送位置通知命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param mobilePositionNotify 位置通知对象
* @param subscribeInfo 订阅信息
* @return callId
*/
public static String sendMobilePositionCommand(FromDevice fromDevice, ToDevice toDevice,
MobilePositionNotify mobilePositionNotify, SubscribeInfo subscribeInfo) {
return sendCommand("MESSAGE", fromDevice, toDevice, mobilePositionNotify);
}
// ==================== 设备更新相关命令 ====================
/**
* 发送设备通道更新通知命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 通道列表
* @return callId
*/
public static String sendDeviceChannelUpdateCommand(FromDevice fromDevice, ToDevice toDevice,
List<DeviceUpdateItem> deviceItems) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceItems);
}
/**
* 发送设备其他更新通知命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 推送事件列表
* @return callId
*/
public static String sendDeviceOtherUpdateCommand(FromDevice fromDevice, ToDevice toDevice,
List<DeviceOtherUpdateNotify.OtherItem> deviceItems) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceItems);
}
// ==================== 录像相关命令 ====================
/**
* 发送录像响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceRecord 录像响应对象
* @return callId
*/
public static String sendDeviceRecordCommand(FromDevice fromDevice, ToDevice toDevice, DeviceRecord deviceRecord) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceRecord);
}
/**
* 发送录像响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceRecordItems 录像文件列表
* @return callId
*/
public static String sendDeviceRecordCommand(FromDevice fromDevice, ToDevice toDevice,
List<DeviceRecord.RecordItem> deviceRecordItems) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceRecordItems);
}
// ==================== 配置相关命令 ====================
/**
* 发送设备配置响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceConfigResponse 配置响应对象
* @return callId
*/
public static String sendDeviceConfigCommand(FromDevice fromDevice, ToDevice toDevice, DeviceConfigResponse deviceConfigResponse) {
return sendCommand("MESSAGE", fromDevice, toDevice, deviceConfigResponse);
}
/**
* 发送设备配置查询应答
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param response 配置查询应答对象
* @return callId
*/
public static String sendConfigDownloadResponse(FromDevice fromDevice, ToDevice toDevice, ConfigDownloadResponse response) {
return sendCommand("MESSAGE", fromDevice, toDevice, response);
}
// ==================== 媒体状态相关命令 ====================
/**
* 发送媒体状态通知命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param notifyType 通知类型 121
* @return callId
*/
public static String sendMediaStatusCommand(FromDevice fromDevice, ToDevice toDevice, String notifyType) {
MediaStatusNotify mediaStatusNotify = new MediaStatusNotify(
CmdTypeEnum.MEDIA_STATUS.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
mediaStatusNotify.setNotifyType(notifyType);
return sendCommand("MESSAGE", fromDevice, toDevice, mediaStatusNotify);
}
/**
* 发送设备预置位查询应答
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param response 预置位查询应答对象
* @return callId
*/
public static String sendPresetQueryResponse(FromDevice fromDevice, ToDevice toDevice, PresetQueryResponse response) {
return sendCommand("MESSAGE", fromDevice, toDevice, response);
}
/**
* 发送设备预置位查询应答
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param response 预置位查询应答对象
* @return callId
*/
public static String sendMobilePositionNotify(FromDevice fromDevice, ToDevice toDevice, MobilePositionNotify response) {
return sendCommand("MESSAGE", fromDevice, toDevice, response);
}
// ==================== 会话控制相关命令 ====================
/**
* 发送BYE请求命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @return callId
*/
public static String sendByeCommand(FromDevice fromDevice, ToDevice toDevice) {
return sendCommand("BYE", fromDevice, toDevice);
}
/**
* 发送ACK响应命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @return callId
*/
public static String sendAckCommand(FromDevice fromDevice, ToDevice toDevice) {
return sendCommand("ACK", fromDevice, toDevice);
}
/**
* 发送ACK响应命令（指定callId）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param callId 呼叫ID
* @return callId
*/
public static String sendAckCommand(FromDevice fromDevice, ToDevice toDevice, String callId) {
return sendCommand("ACK", fromDevice, toDevice, callId);
}
/**
* 发送ACK响应命令（带内容和callId）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param content 内容
* @param callId 呼叫ID
* @return callId
*/
public static String sendAckCommand(FromDevice fromDevice, ToDevice toDevice, String content, String callId) {
return sendCommand("ACK", fromDevice, toDevice, content, callId);
}
// ==================== 点播相关命令 ====================
/**
* 发送实时点播命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param sdpContent SDP内容
* @return callId
*/
public static String sendInvitePlayCommand(FromDevice fromDevice, ToDevice toDevice, String sdpContent) {
return sendCommand("INVITE", fromDevice, toDevice, sdpContent);
}
/**
* 发送实时点播命令（带事件）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param sdpContent SDP内容
* @param errorEvent 错误事件
* @param okEvent 成功事件
* @return callId
*/
public static String sendInvitePlayCommand(FromDevice fromDevice, ToDevice toDevice, String sdpContent, Event errorEvent, Event okEvent) {
return sendCommand("INVITE", fromDevice, toDevice, errorEvent, okEvent, sdpContent);
}
/**
* 发送回放点播命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param sdpContent SDP内容
* @return callId
*/
public static String sendInvitePlayBackCommand(FromDevice fromDevice, ToDevice toDevice, String sdpContent) {
return sendCommand("INVITE", fromDevice, toDevice, sdpContent);
}
/**
* 发送回放点播命令（带事件）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param sdpContent SDP内容
* @param errorEvent 错误事件
* @param okEvent 成功事件
* @return callId
*/
public static String sendInvitePlayBackCommand(FromDevice fromDevice, ToDevice toDevice, String sdpContent, Event errorEvent, Event okEvent) {
return sendCommand("INVITE", fromDevice, toDevice, errorEvent, okEvent, sdpContent);
}
/**
* 发送点播控制命令（暂停、继续、快进等）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param controlContent 控制内容
* @return callId
*/
public static String sendInvitePlayControlCommand(FromDevice fromDevice, ToDevice toDevice, String controlContent) {
return sendCommand("MESSAGE", fromDevice, toDevice, controlContent);
}
// ==================== 注册相关命令 ====================
/**
* 发送注册命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param expires 过期时间
* @return callId
*/
public static String sendRegisterCommand(FromDevice fromDevice, ToDevice toDevice, Integer expires) {
Assert.isTrue(expires >= 0, "过期时间应该 >= 0");
return sendCommand("REGISTER", fromDevice, toDevice, expires);
}
/**
* 发送注册命令（带事件）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param expires 过期时间
* @param event 事件
* @return callId
*/
public static String sendRegisterCommand(FromDevice fromDevice, ToDevice toDevice, Integer expires, Event event) {
Assert.isTrue(expires >= 0, "过期时间应该 >= 0");
return sendCommand("REGISTER", fromDevice, toDevice, event, null, expires);
}
/**
* 发送注销命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @return callId
*/
public static String sendUnregisterCommand(FromDevice fromDevice, ToDevice toDevice) {
return sendCommand("REGISTER", fromDevice, toDevice, 0);
}
// ==================== 建造者模式 ====================
/**
* 命令发送建造者
* 提供流式API，支持链式调用
*/
public static class CommandBuilder {
private String commandType;
private FromDevice fromDevice;
private ToDevice toDevice;
private Event errorEvent;
private Event okEvent;
private SubscribeInfo subscribeInfo;
private Object[] params;
public CommandBuilder commandType(String commandType) {
this.commandType = commandType;
return this;
}
public CommandBuilder fromDevice(FromDevice fromDevice) {
this.fromDevice = fromDevice;
return this;
}
public CommandBuilder toDevice(ToDevice toDevice) {
this.toDevice = toDevice;
return this;
}
public CommandBuilder errorEvent(Event errorEvent) {
this.errorEvent = errorEvent;
return this;
}
public CommandBuilder okEvent(Event okEvent) {
this.okEvent = okEvent;
return this;
}
public CommandBuilder subscribeInfo(SubscribeInfo subscribeInfo) {
this.subscribeInfo = subscribeInfo;
return this;
}
public CommandBuilder params(Object... params) {
this.params = params;
return this;
}
public String execute() {
if (subscribeInfo != null) {
return sendCommand(commandType, fromDevice, toDevice, subscribeInfo, params);
} else {
return sendCommand(commandType, fromDevice, toDevice, errorEvent, okEvent, params);
}
}
}
/**
* 创建命令建造者
*
* @return 命令建造者
*/
public static CommandBuilder builder() {
return new CommandBuilder();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/ClientSendCmd.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/ClientSendCmd.java | package io.github.lunasaw.gbproxy.client.transmit.cmd;
import java.util.List;
import java.util.Optional;
import com.google.common.collect.Lists;
import com.luna.common.check.Assert;
import com.luna.common.text.RandomStrUtil;
import io.github.lunasaw.gb28181.common.entity.DeviceAlarm;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.gb28181.common.entity.notify.*;
import io.github.lunasaw.gb28181.common.entity.response.*;
import io.github.lunasaw.gb28181.common.entity.enums.CmdTypeEnum;
import io.github.lunasaw.sip.common.subscribe.SubscribeInfo;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* GB28181客户端命令发送器
* 提供统一的SIP命令发送接口，支持各种GB28181协议命令
*
* @author luna
* @date 2023/10/15
*/
@Deprecated
@Slf4j
public class ClientSendCmd {
// ==================== 告警相关命令 ====================
/**
* 告警上报
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceAlarmNotify 告警通知对象
* @return callId
*/
public static String deviceAlarmNotify(FromDevice fromDevice, ToDevice toDevice, DeviceAlarmNotify deviceAlarmNotify) {
return SipSender.doMessageRequest(fromDevice, toDevice, deviceAlarmNotify.toString());
}
/**
* 告警上报
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceAlarm 告警信息
* @return callId
*/
public static String deviceAlarmNotify(FromDevice fromDevice, ToDevice toDevice, DeviceAlarm deviceAlarm) {
DeviceAlarmNotify deviceAlarmNotify = new DeviceAlarmNotify(
CmdTypeEnum.ALARM.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceAlarmNotify.setAlarm(deviceAlarm);
return SipSender.doMessageRequest(fromDevice, toDevice, deviceAlarmNotify.toString());
}
// ==================== 心跳相关命令 ====================
/**
* 心跳设备状态上报
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param status 状态信息
* @return callId
*/
public static String deviceKeepLiveNotify(FromDevice fromDevice, ToDevice toDevice, String status) {
return deviceKeepLiveNotify(fromDevice, toDevice, status, null, null);
}
/**
* 心跳设备状态上报（带错误事件）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param status 状态信息
* @param errorEvent 错误事件
* @return callId
*/
public static String deviceKeepLiveNotify(FromDevice fromDevice, ToDevice toDevice, String status, Event errorEvent) {
return deviceKeepLiveNotify(fromDevice, toDevice, status, errorEvent, null);
}
/**
* 心跳设备状态上报（带完整事件）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param status 状态信息
* @param errorEvent 错误事件
* @param okEvent 成功事件
* @return callId
*/
public static String deviceKeepLiveNotify(FromDevice fromDevice, ToDevice toDevice, String status, Event errorEvent, Event okEvent) {
DeviceKeepLiveNotify deviceKeepLiveNotify = new DeviceKeepLiveNotify(
CmdTypeEnum.KEEPALIVE.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceKeepLiveNotify.setStatus(status);
return SipSender.doMessageRequest(fromDevice, toDevice, deviceKeepLiveNotify.toString(), errorEvent, okEvent);
}
// ==================== 设备目录相关命令 ====================
/**
* 设备目录查询响应
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceResponse 设备响应对象
* @return callId
*/
public static String deviceChannelCatalogResponse(FromDevice fromDevice, ToDevice toDevice, DeviceResponse deviceResponse) {
return SipSender.doMessageRequest(fromDevice, toDevice, deviceResponse.toString());
}
/**
* 设备目录查询响应（分批发送）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 设备列表
* @param sn 序列号
*/
public static void deviceChannelCatalogResponse(FromDevice fromDevice, ToDevice toDevice, List<DeviceItem> deviceItems, String sn) {
DeviceResponse deviceResponse = new DeviceResponse(
CmdTypeEnum.CATALOG.getType(),
sn,
fromDevice.getUserId()
);
// 分批发送，每批20个设备
List<List<DeviceItem>> partition = Lists.partition(deviceItems, 20);
for (List<DeviceItem> items : partition) {
deviceResponse.setSumNum(deviceItems.size());
deviceResponse.setDeviceItemList(items);
deviceChannelCatalogResponse(fromDevice, toDevice, deviceResponse);
}
}
/**
* 上报设备信息
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 通道状态列表
* @return callId
*/
public static String deviceChannelCatalogResponse(FromDevice fromDevice, ToDevice toDevice, List<DeviceItem> deviceItems) {
DeviceResponse deviceResponse = new DeviceResponse(
CmdTypeEnum.CATALOG.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceResponse.setSumNum(deviceItems.size());
deviceResponse.setDeviceItemList(deviceItems);
return deviceChannelCatalogResponse(fromDevice, toDevice, deviceResponse);
}
// ==================== 设备信息相关命令 ====================
/**
* 向上级回复DeviceInfo查询信息
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceInfo 设备信息
* @return callId
*/
public static String deviceInfoResponse(FromDevice fromDevice, ToDevice toDevice, DeviceInfo deviceInfo) {
Assert.notNull(deviceInfo, "deviceInfo is null");
deviceInfo.setCmdType(CmdTypeEnum.DEVICE_INFO.getType());
if (deviceInfo.getSn() == null) {
deviceInfo.setSn(RandomStrUtil.getValidationCode());
}
return SipSender.doMessageRequest(fromDevice, toDevice, deviceInfo.toString());
}
/**
* 推送设备状态信息
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param online 在线状态 "ONLINE":"OFFLINE"
* @return callId
*/
public static String deviceStatusResponse(FromDevice fromDevice, ToDevice toDevice, String online) {
DeviceStatus deviceStatus = new DeviceStatus(
CmdTypeEnum.DEVICE_STATUS.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceStatus.setOnline(online);
return SipSender.doMessageRequest(fromDevice, toDevice, deviceStatus.toString());
}
// ==================== 位置信息相关命令 ====================
/**
* 设备位置推送
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param mobilePositionNotify 位置通知对象
* @param subscribeInfo 订阅信息
* @return callId
*/
public static String MobilePositionNotify(FromDevice fromDevice, ToDevice toDevice, MobilePositionNotify mobilePositionNotify,
SubscribeInfo subscribeInfo) {
mobilePositionNotify.setCmdType(CmdTypeEnum.MOBILE_POSITION.getType());
if (mobilePositionNotify.getSn() == null) {
mobilePositionNotify.setSn(RandomStrUtil.getValidationCode());
}
mobilePositionNotify.setDeviceId(fromDevice.getUserId());
return SipSender.doNotifyRequest(fromDevice, toDevice, mobilePositionNotify.toString(), subscribeInfo, null, null);
}
// ==================== 设备更新相关命令 ====================
/**
* 设备通道更新通知
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 通道列表
* @param subscribeInfo 订阅信息
* @return callId
*/
public static String deviceChannelUpdateCatlog(FromDevice fromDevice, ToDevice toDevice, List<DeviceUpdateItem> deviceItems,
SubscribeInfo subscribeInfo) {
DeviceUpdateNotify deviceUpdateNotify = new DeviceUpdateNotify(
CmdTypeEnum.CATALOG.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceUpdateNotify.setSumNum(deviceItems.size());
deviceUpdateNotify.setDeviceItemList(deviceItems);
return SipSender.doNotifyRequest(fromDevice, toDevice, deviceUpdateNotify.toString(), subscribeInfo, null, null);
}
/**
* 事件更新推送
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceItems 推送事件列表
* @param subscribeInfo 订阅信息
* @return callId
*/
public static String deviceOtherUpdateCatlog(FromDevice fromDevice, ToDevice toDevice, List<DeviceOtherUpdateNotify.OtherItem> deviceItems,
SubscribeInfo subscribeInfo) {
DeviceOtherUpdateNotify deviceUpdateNotify = new DeviceOtherUpdateNotify(
CmdTypeEnum.CATALOG.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
deviceUpdateNotify.setSumNum(deviceItems.size());
deviceUpdateNotify.setDeviceItemList(deviceItems);
return SipSender.doNotifyRequest(fromDevice, toDevice, deviceUpdateNotify.toString(), subscribeInfo, null, null);
}
// ==================== 录像相关命令 ====================
/**
* 设备录像上报
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceRecord 录像响应对象
* @return callId
*/
public static String deviceRecordResponse(FromDevice fromDevice, ToDevice toDevice, DeviceRecord deviceRecord) {
return SipSender.doMessageRequest(fromDevice, toDevice, deviceRecord.toString());
}
/**
* 设备录像上报（分批发送）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceRecordItems 录像文件列表
* @param sn 序列号
*/
public static void deviceRecordResponse(FromDevice fromDevice, ToDevice toDevice, List<DeviceRecord.RecordItem> deviceRecordItems, String sn) {
sn = Optional.ofNullable(sn).orElse(RandomStrUtil.getValidationCode());
DeviceRecord deviceRecord = new DeviceRecord(
CmdTypeEnum.RECORD_INFO.getType(),
sn,
fromDevice.getUserId()
);
// 分批发送，每批20个录像文件
List<List<DeviceRecord.RecordItem>> partition = Lists.partition(deviceRecordItems, 20);
for (List<DeviceRecord.RecordItem> recordItems : partition) {
deviceRecord.setSumNum(deviceRecordItems.size());
deviceRecord.setRecordList(recordItems);
deviceRecordResponse(fromDevice, toDevice, deviceRecord);
}
}
// ==================== 配置相关命令 ====================
/**
* 设备配置上报
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param deviceConfigResponse 配置响应对象
* @return callId
*/
public static String deviceConfigResponse(FromDevice fromDevice, ToDevice toDevice, DeviceConfigResponse deviceConfigResponse) {
return SipSender.doMessageRequest(fromDevice, toDevice, deviceConfigResponse.toString());
}
// ==================== 媒体状态相关命令 ====================
/**
* 流媒体状态推送
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param notifyType 通知类型 121
* @return callId
*/
public static String deviceMediaStatusNotify(FromDevice fromDevice, ToDevice toDevice, String notifyType) {
MediaStatusNotify mediaStatusNotify = new MediaStatusNotify(
CmdTypeEnum.MEDIA_STATUS.getType(),
RandomStrUtil.getValidationCode(),
fromDevice.getUserId()
);
mediaStatusNotify.setNotifyType(notifyType);
return SipSender.doMessageRequest(fromDevice, toDevice, mediaStatusNotify.toString());
}
// ==================== 会话控制相关命令 ====================
/**
* 向上级发送BYE请求
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @return callId
*/
public static String deviceBye(FromDevice fromDevice, ToDevice toDevice) {
return SipSender.doByeRequest(fromDevice, toDevice);
}
/**
* 回复ACK响应
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @return callId
*/
public static String deviceAck(FromDevice fromDevice, ToDevice toDevice) {
return SipSender.doAckRequest(fromDevice, toDevice);
}
/**
* 回复ACK响应（指定callId）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param callId 呼叫ID
* @return callId
*/
public static String deviceAck(FromDevice fromDevice, ToDevice toDevice, String callId) {
return SipSender.doAckRequest(fromDevice, toDevice, callId);
}
/**
* 回复ACK响应（带内容和callId）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param content 内容
* @param callId 呼叫ID
* @return callId
*/
public static String deviceAck(FromDevice fromDevice, ToDevice toDevice, String content, String callId) {
return SipSender.doAckRequest(fromDevice, toDevice, content, callId);
}
// ==================== 注册相关命令 ====================
/**
* 设备注册
*
* @param fromDevice 当前设备
* @param toDevice 注册平台
* @param expires 注册时间 0注销
* @return callId
*/
public static String deviceRegister(FromDevice fromDevice, ToDevice toDevice, Integer expires) {
return SipSender.doRegisterRequest(fromDevice, toDevice, expires);
}
/**
* 设备注册（带事件）
*
* @param fromDevice 当前设备
* @param toDevice 注册平台
* @param expires 注册时间 0注销
* @param event 事件
* @return callId
*/
public static String deviceRegister(FromDevice fromDevice, ToDevice toDevice, Integer expires, Event event) {
return SipSender.doRegisterRequest(fromDevice, toDevice, expires, event);
}
/**
* 设备注销
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @return callId
*/
public static String deviceUnRegister(FromDevice fromDevice, ToDevice toDevice) {
return SipSender.doRegisterRequest(fromDevice, toDevice, 0);
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/ClientCommandStrategyFactory.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/ClientCommandStrategyFactory.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.MessageCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.SubscribeCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.NotifyCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.InviteCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.ByeCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.AckCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.InfoCommandStrategy;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl.RegisterCommandStrategy;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 客户端SIP消息类型策略工厂
* 管理和获取不同类型的SIP消息处理策略
* 符合SIP协议架构要求，处理MESSAGE、SUBSCRIBE、NOTIFY、INVITE、BYE、ACK等SIP消息类型
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class ClientCommandStrategyFactory {
private static final Map<String, ClientCommandStrategy> STRATEGY_MAP = new ConcurrentHashMap<>();
static {
// 只保留SIP基础协议的消息类型策略
STRATEGY_MAP.put("MESSAGE", new MessageCommandStrategy());
STRATEGY_MAP.put("SUBSCRIBE", new SubscribeCommandStrategy());
STRATEGY_MAP.put("NOTIFY", new NotifyCommandStrategy());
STRATEGY_MAP.put("INVITE", new InviteCommandStrategy());
STRATEGY_MAP.put("BYE", new ByeCommandStrategy());
STRATEGY_MAP.put("ACK", new AckCommandStrategy());
STRATEGY_MAP.put("INFO", new InfoCommandStrategy());
STRATEGY_MAP.put("REGISTER", new RegisterCommandStrategy());
log.info("客户端SIP消息类型策略工厂初始化完成，已注册策略: {}", STRATEGY_MAP.keySet());
}
// 只保留基础SIP方法的获取接口
public static ClientCommandStrategy getStrategy(String sipMethod) {
ClientCommandStrategy strategy = STRATEGY_MAP.get(sipMethod);
if (strategy == null) {
throw new IllegalArgumentException("未找到SIP消息类型策略: " + sipMethod);
}
return strategy;
}
public static ClientCommandStrategy getMessageStrategy() {
return getStrategy("MESSAGE");
}
public static ClientCommandStrategy getSubscribeStrategy() {
return getStrategy("SUBSCRIBE");
}
public static ClientCommandStrategy getNotifyStrategy() {
return getStrategy("NOTIFY");
}
public static ClientCommandStrategy getInviteStrategy() {
return getStrategy("INVITE");
}
public static ClientCommandStrategy getByeStrategy() {
return getStrategy("BYE");
}
public static ClientCommandStrategy getAckStrategy() {
return getStrategy("ACK");
}
public static ClientCommandStrategy getInfoStrategy() {
return getStrategy("INFO");
}
public static ClientCommandStrategy getRegisterStrategy() {
return getStrategy("REGISTER");
}
// 删除自定义注册、移除、查询等非必要方法，只保留基础功能
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/AbstractClientCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/AbstractClientCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy;
import com.luna.common.check.Assert;
import com.luna.common.text.RandomStrUtil;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* 抽象客户端命令策略基类
* 提供通用的命令执行逻辑和工具方法
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public abstract class AbstractClientCommandStrategy implements ClientCommandStrategy {
@Override
public String execute(FromDevice fromDevice, ToDevice toDevice, Object... params) {
return execute(fromDevice, toDevice, null, null, params);
}
@Override
public String execute(FromDevice fromDevice, ToDevice toDevice, Event errorEvent, Event okEvent, Object... params) {
try {
Assert.notNull(fromDevice, "发送设备不能为空");
Assert.notNull(toDevice, "接收设备不能为空");
log.debug("执行命令: {}, 发送设备: {}, 接收设备: {}", getCommandType(), fromDevice.getUserId(), toDevice.getUserId());
// 参数校验
validateParams(fromDevice, toDevice, params);
// 构建命令内容
String content = buildCommandContent(fromDevice, toDevice, params);
// 发送命令
String callId = sendCommand(fromDevice, toDevice, content, errorEvent, okEvent);
log.debug("命令执行成功: {}, callId: {}", getCommandType(), callId);
return callId;
} catch (Exception e) {
log.error("命令执行失败: {}, 错误信息: {}", getCommandType(), e.getMessage(), e);
throw e;
}
}
/**
* 参数校验
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param params 参数
*/
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
Assert.notNull(fromDevice, "发送设备不能为空");
Assert.notNull(toDevice, "接收设备不能为空");
Assert.notNull(fromDevice.getUserId(), "发送设备ID不能为空");
Assert.notNull(toDevice.getUserId(), "接收设备ID不能为空");
}
/**
* 构建命令内容
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param params 参数
* @return 命令内容
*/
protected String buildCommandContent(FromDevice fromDevice, ToDevice toDevice, Object... params) {
// 默认实现：获取第一个String类型的参数
if (params.length > 0 && params[0] instanceof String) {
return (String) params[0];
}
return null;
}
/**
* 发送命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param content 命令内容
* @param errorEvent 错误事件
* @param okEvent 成功事件
* @return callId
*/
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
return SipSender.doMessageRequest(fromDevice, toDevice, content, errorEvent, okEvent);
}
/**
* 生成随机序列号
*
* @return 序列号
*/
protected String generateSn() {
return RandomStrUtil.getValidationCode();
}
/**
* 获取设备ID
*
* @param fromDevice 发送设备
* @return 设备ID
*/
protected String getDeviceId(FromDevice fromDevice) {
return fromDevice.getUserId();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/ClientCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/ClientCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.event.Event;
/**
* 客户端命令策略接口
* 定义统一的命令执行策略，支持不同类型的GB28181命令
*
* @author luna
* @date 2024/01/01
*/
public interface ClientCommandStrategy {
/**
* 执行命令
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param params 命令参数
* @return callId
*/
String execute(FromDevice fromDevice, ToDevice toDevice, Object... params);
/**
* 执行命令（带事件）
*
* @param fromDevice 发送设备
* @param toDevice 接收设备
* @param errorEvent 错误事件
* @param okEvent 成功事件
* @param params 命令参数
* @return callId
*/
String execute(FromDevice fromDevice, ToDevice toDevice, Event errorEvent, Event okEvent, Object... params);
/**
* 获取命令类型
*
* @return 命令类型
*/
String getCommandType();
/**
* 获取命令描述
*
* @return 命令描述
*/
String getCommandDescription();
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/SubscribeCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/SubscribeCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* SUBSCRIBE消息类型策略实现
* 处理SUBSCRIBE请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class SubscribeCommandStrategy extends AbstractClientCommandStrategy {
@Override
public String getCommandType() {
return "SUBSCRIBE";
}
@Override
public String getCommandDescription() {
return "SUBSCRIBE请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 发送SUBSCRIBE请求
return SipSender.doSubscribeRequest(fromDevice, toDevice, content, errorEvent, okEvent);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/ByeCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/ByeCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* BYE命令策略实现
* 处理BYE请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class ByeCommandStrategy extends AbstractClientCommandStrategy {
@Override
public String getCommandType() {
return "BYE";
}
@Override
public String getCommandDescription() {
return "BYE请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 直接发送BYE请求，不通过MESSAGE
return SipSender.doByeRequest(fromDevice, toDevice);
}
@Override
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
super.validateParams(fromDevice, toDevice, params);
// BYE命令不需要额外参数校验
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/NotifyCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/NotifyCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* NOTIFY消息类型策略实现
* 处理NOTIFY请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class NotifyCommandStrategy extends AbstractClientCommandStrategy {
@Override
public String getCommandType() {
return "NOTIFY";
}
@Override
public String getCommandDescription() {
return "NOTIFY请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 发送NOTIFY请求
return SipSender.doNotifyRequest(fromDevice, toDevice, content, errorEvent, okEvent);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/MessageCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/MessageCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import io.github.lunasaw.sip.common.utils.XmlUtils;
import lombok.extern.slf4j.Slf4j;
/**
* MESSAGE消息类型策略实现
* 处理MESSAGE请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class MessageCommandStrategy extends AbstractClientCommandStrategy {
@Override
protected String buildCommandContent(FromDevice fromDevice, ToDevice toDevice, Object... params) {
// MESSAGE命令需要构建XML内容
if (params.length > 0) {
Object param = params[0];
// 如果参数是字符串，使用父类默认实现
if (param instanceof String) {
return super.buildCommandContent(fromDevice, toDevice, params);
}
// 如果参数是对象，尝试转换为XML
if (param != null) {
try {
// 使用XmlUtils将对象序列化为XML
return XmlUtils.toString("UTF-8", param);
} catch (Exception e) {
log.error("参数转换失败: {}", param, e);
throw new IllegalArgumentException("参数转换失败: " + param);
}
}
}
return null;
}
@Override
public String getCommandType() {
return "MESSAGE";
}
@Override
public String getCommandDescription() {
return "MESSAGE请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 发送MESSAGE请求
return SipSender.doMessageRequest(fromDevice, toDevice, content, errorEvent, okEvent);
}
@Override
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
super.validateParams(fromDevice, toDevice, params);
// MESSAGE命令需要内容参数
if (params.length == 0 || params[0] == null) {
throw new IllegalArgumentException("MESSAGE命令需要提供内容参数");
}
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/RegisterCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/RegisterCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* REGISTER消息类型策略实现
* 处理REGISTER注册请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class RegisterCommandStrategy extends AbstractClientCommandStrategy {
@Override
protected String buildCommandContent(FromDevice fromDevice, ToDevice toDevice, Object... params) {
// REGISTER命令不需要构建内容，expires参数直接传递给SipSender
return null;
}
@Override
public String getCommandType() {
return "REGISTER";
}
@Override
public String getCommandDescription() {
return "REGISTER注册请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 从参数中获取expires值
Integer expires = getExpiresFromParams();
if (expires == null) {
expires = 3600; // 默认过期时间
}
// 发送REGISTER请求
return SipSender.doRegisterRequest(fromDevice, toDevice, expires);
}
@Override
public String execute(FromDevice fromDevice, ToDevice toDevice, Event errorEvent, Event okEvent, Object... params) {
try {
// 参数校验
validateParams(fromDevice, toDevice, params);
// 获取过期时间参数
Integer expires = extractExpires(params);
// 直接调用SipSender发送REGISTER请求
String callId = SipSender.doRegisterRequest(fromDevice, toDevice, expires);
log.debug("REGISTER命令执行成功, callId: {}, expires: {}", callId, expires);
return callId;
} catch (Exception e) {
log.error("REGISTER命令执行失败: {}", e.getMessage(), e);
throw e;
}
}
@Override
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
super.validateParams(fromDevice, toDevice, params);
// REGISTER命令需要expires参数
if (params.length == 0) {
throw new IllegalArgumentException("REGISTER命令需要提供expires参数");
}
// 验证expires参数类型
Object expiresParam = params[0];
if (!(expiresParam instanceof Integer)) {
throw new IllegalArgumentException("expires参数必须是Integer类型");
}
Integer expires = (Integer) expiresParam;
if (expires < 0) {
throw new IllegalArgumentException("expires参数必须 >= 0");
}
}
/**
* 从参数中提取expires值
*/
private Integer extractExpires(Object... params) {
if (params.length > 0 && params[0] instanceof Integer) {
return (Integer) params[0];
}
return 3600; // 默认值
}
/**
* 临时变量存储expires，用于传递给sendCommand方法
*/
private Integer currentExpires;
private Integer getExpiresFromParams() {
return currentExpires;
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/InviteCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/InviteCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* INVITE消息类型策略实现
* 处理INVITE请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class InviteCommandStrategy extends AbstractClientCommandStrategy {
@Override
public String getCommandType() {
return "INVITE";
}
@Override
public String getCommandDescription() {
return "INVITE请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 发送INVITE请求
return SipSender.doInviteRequest(fromDevice, toDevice, content, errorEvent, okEvent);
}
@Override
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
super.validateParams(fromDevice, toDevice, params);
// INVITE命令需要SDP内容参数
if (params.length == 0 || !(params[0] instanceof String)) {
throw new IllegalArgumentException("INVITE命令需要提供SDP内容参数");
}
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/AckCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/AckCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* ACK命令策略实现
* 处理ACK响应相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class AckCommandStrategy extends AbstractClientCommandStrategy {
@Override
public String getCommandType() {
return "ACK";
}
@Override
public String getCommandDescription() {
return "ACK响应";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
return SipSender.doAckRequest(fromDevice, toDevice, content, null, errorEvent, okEvent);
}
@Override
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
super.validateParams(fromDevice, toDevice, params);
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/InfoCommandStrategy.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/cmd/strategy/impl/InfoCommandStrategy.java | package io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.impl;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.gbproxy.client.transmit.cmd.strategy.AbstractClientCommandStrategy;
import io.github.lunasaw.sip.common.transmit.event.Event;
import lombok.extern.slf4j.Slf4j;
/**
* INFO消息类型策略实现
* 处理INFO请求相关命令
*
* @author luna
* @date 2024/01/01
*/
@Slf4j
public class InfoCommandStrategy extends AbstractClientCommandStrategy {
@Override
public String getCommandType() {
return "INFO";
}
@Override
public String getCommandDescription() {
return "INFO请求";
}
@Override
protected String sendCommand(FromDevice fromDevice, ToDevice toDevice, String content, Event errorEvent, Event okEvent) {
// 发送INFO请求
return SipSender.doInfoRequest(fromDevice, toDevice, content, errorEvent, okEvent);
}
@Override
protected void validateParams(FromDevice fromDevice, ToDevice toDevice, Object... params) {
super.validateParams(fromDevice, toDevice, params);
// INFO命令需要内容参数
if (params.length == 0 || !(params[0] instanceof String)) {
throw new IllegalArgumentException("INFO命令需要提供内容参数");
}
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ClientAbstractSipResponseProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ClientAbstractSipResponseProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.response;
import io.github.lunasaw.sip.common.transmit.event.response.AbstractSipResponseProcessor;
/**
* @author luna
*/
public abstract class ClientAbstractSipResponseProcessor extends AbstractSipResponseProcessor {
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/package-info.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/package-info.java | /**
* SIP客户端请求发送后接受的响应处理
*
* @author luna
* 2021/8/18
*/
package io.github.lunasaw.gbproxy.client.transmit.response;
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ack/ClientAckProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ack/ClientAckProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.ack;
import javax.sip.ResponseEvent;
/**
* ACK响应处理器业务接口
*
* @author luna
*/
public interface ClientAckProcessorHandler {
/**
* 处理ACK响应
*
* @param callId 呼叫ID
* @param evt 响应事件
*/
default void handleAckResponse(String callId, ResponseEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ack/DefaultClientAckProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ack/DefaultClientAckProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.ack;
import javax.sip.ResponseEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* 默认ACK处理器实现
*
* @author luna
*/
@Slf4j
@Component
@ConditionalOnMissingBean(ClientAckProcessorHandler.class)
public class DefaultClientAckProcessorHandler implements ClientAckProcessorHandler {
@Override
public void handleAckResponse(String callId, ResponseEvent evt) {
log.debug("处理ACK响应：callId = {}", callId);
// 默认实现为空，业务方可以根据需要重写此方法
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ack/ClientAckResponseProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/ack/ClientAckResponseProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.response.ack;
import io.github.lunasaw.gbproxy.client.transmit.response.ClientAbstractSipResponseProcessor;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import javax.sip.ResponseEvent;
import javax.sip.header.CallIdHeader;
/**
* ACK响应处理器
* 只负责SIP协议层面的处理，业务逻辑通过AckProcessorHandler接口实现
*
* @author luna
*/
@Slf4j
@Getter
@Setter
@Component("clientAckResponseProcessor")
public class ClientAckResponseProcessor extends ClientAbstractSipResponseProcessor {
public static final String METHOD = "ACK";
private String method = METHOD;
@Autowired
@Lazy
private ClientAckProcessorHandler ackProcessorHandler;
/**
* 处理ACK响应
*
* @param evt 响应事件
*/
@Override
public void process(ResponseEvent evt) {
try {
CallIdHeader callIdHeader = (CallIdHeader) evt.getResponse().getHeader(CallIdHeader.NAME);
String callId = callIdHeader != null ? callIdHeader.getCallId() : null;
if (callId != null) {
ackProcessorHandler.handleAckResponse(callId, evt);
log.debug("处理ACK响应：callId = {}", callId);
} else {
log.warn("ACK响应处理失败：callId为空");
}
} catch (Exception e) {
log.error("处理ACK响应异常：evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/cancel/CancelResponseProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/cancel/CancelResponseProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.response.cancel;
import gov.nist.javax.sip.message.SIPResponse;
import io.github.lunasaw.gbproxy.client.transmit.response.ClientAbstractSipResponseProcessor;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import javax.sip.ResponseEvent;
/**
* CANCEL响应处理器
* 只负责SIP协议层面的处理，业务逻辑通过CancelProcessorHandler接口实现
*
* @author luna
*/
@Slf4j
@Getter
@Setter
@Component("clientCancelResponseProcessor")
public class CancelResponseProcessor extends ClientAbstractSipResponseProcessor {
public static final String METHOD = "CANCEL";
private String method = METHOD;
@Autowired
@Lazy
private CancelProcessorHandler cancelProcessorHandler;
/**
* 处理CANCEL响应
*
* @param evt 响应事件
*/
@Override
public void process(ResponseEvent evt) {
try {
SIPResponse response = (SIPResponse) evt.getResponse();
String callId = response.getCallIdHeader().getCallId();
int statusCode = response.getStatusCode();
if (callId != null) {
cancelProcessorHandler.handleCancelResponse(callId, statusCode, evt);
log.info("处理CANCEL响应：callId = {}, statusCode = {}", callId, statusCode);
} else {
log.warn("CANCEL响应处理失败：callId为空");
}
} catch (Exception e) {
log.error("处理CANCEL响应异常：evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/cancel/DefaultCancelProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/cancel/DefaultCancelProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.cancel;
import javax.sip.ResponseEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* 默认CANCEL处理器实现
*
* @author luna
*/
@Slf4j
@Component
@ConditionalOnMissingBean(CancelProcessorHandler.class)
public class DefaultCancelProcessorHandler implements CancelProcessorHandler {
@Override
public void handleCancelResponse(String callId, int statusCode, ResponseEvent evt) {
log.debug("处理CANCEL响应：callId = {}, statusCode = {}", callId, statusCode);
// 默认实现为空，业务方可以根据需要重写此方法
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/cancel/CancelProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/cancel/CancelProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.cancel;
import javax.sip.ResponseEvent;
/**
* CANCEL响应处理器业务接口
*
* @author luna
*/
public interface CancelProcessorHandler {
/**
* 处理CANCEL响应
*
* @param callId 呼叫ID
* @param statusCode 状态码
* @param evt 响应事件
*/
default void handleCancelResponse(String callId, int statusCode, ResponseEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/bye/DefaultClientByeProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/bye/DefaultClientByeProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.bye;
import javax.sip.ResponseEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* 默认BYE处理器实现
*
* @author luna
*/
@Slf4j
@Component
@ConditionalOnMissingBean(ClientByeProcessorHandler.class)
public class DefaultClientByeProcessorHandler implements ClientByeProcessorHandler {
@Override
public void handleByeResponse(String callId, int statusCode, ResponseEvent evt) {
log.debug("处理BYE响应：callId = {}, statusCode = {}", callId, statusCode);
// 默认实现为空，业务方可以根据需要重写此方法
}
@Override
public void closeStream(String callId) {
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/bye/ClientByeProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/bye/ClientByeProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.bye;
import javax.sip.ResponseEvent;
/**
* BYE响应处理器业务接口
*
* @author luna
*/
public interface ClientByeProcessorHandler {
/**
* 处理BYE响应
*
* @param callId 呼叫ID
* @param statusCode 状态码
* @param evt 响应事件
*/
default void handleByeResponse(String callId, int statusCode, ResponseEvent evt) {
// 默认实现为空，由业务方根据需要实现
}
void closeStream(String callId);
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/bye/ByeResponseProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/bye/ByeResponseProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.response.bye;
import javax.sip.ResponseEvent;
import gov.nist.javax.sip.message.SIPResponse;
import io.github.lunasaw.gbproxy.client.transmit.response.ClientAbstractSipResponseProcessor;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
/**
* BYE响应处理器
* 只负责SIP协议层面的处理，业务逻辑通过ByeProcessorHandler接口实现
*
* @author luna
*/
@Slf4j
@Getter
@Setter
@Component("clientByeResponseProcessor")
public class ByeResponseProcessor extends ClientAbstractSipResponseProcessor {
public static final String METHOD = "BYE";
private String method = METHOD;
@Autowired
@Lazy
private ClientByeProcessorHandler clientByeProcessorHandler;
/**
* 处理BYE响应
*
* @param evt 响应事件
*/
@Override
public void process(ResponseEvent evt) {
try {
SIPResponse response = (SIPResponse) evt.getResponse();
String callId = response.getCallIdHeader().getCallId();
int statusCode = response.getStatusCode();
if (callId != null) {
clientByeProcessorHandler.handleByeResponse(callId, statusCode, evt);
log.info("处理BYE响应：callId = {}, statusCode = {}", callId, statusCode);
} else {
log.warn("BYE响应处理失败：callId为空");
}
} catch (Exception e) {
log.error("处理BYE响应异常：evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/register/ClientRegisterResponseProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/register/ClientRegisterResponseProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.response.register;
import gov.nist.javax.sip.ResponseEventExt;
import gov.nist.javax.sip.message.SIPResponse;
import io.github.lunasaw.gbproxy.client.config.SipClientProperties;
import io.github.lunasaw.gbproxy.client.transmit.response.ClientAbstractSipResponseProcessor;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import io.github.lunasaw.sip.common.service.TimeSyncService;
import io.github.lunasaw.sip.common.transmit.SipSender;
import io.github.lunasaw.sip.common.transmit.request.SipRequestBuilderFactory;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import javax.sip.ResponseEvent;
import javax.sip.header.CallIdHeader;
import javax.sip.header.DateHeader;
import javax.sip.header.WWWAuthenticateHeader;
import javax.sip.message.Request;
import javax.sip.message.Response;
import java.util.Calendar;
/**
* Register响应处理器
* 只负责SIP协议层面的处理，业务逻辑通过RegisterProcessorHandler接口实现
* 这个是客户端发起的REGISTER后，服务端回复的REGISTER响应处理器
*
* @author luna
*/
@Slf4j
@Getter
@Setter
@Component("clientRegisterResponseProcessor")
public class ClientRegisterResponseProcessor extends ClientAbstractSipResponseProcessor {
public static final String METHOD = "REGISTER";
private String method = METHOD;
@Autowired
private ClientDeviceSupplier deviceSupplier;
@Autowired
@Lazy
private RegisterProcessorHandler registerProcessorHandler;
@Autowired
private TimeSyncService timeSyncService;
/**
* 处理Register响应
*
* @param evt 事件
*/
@Override
public void process(ResponseEvent evt) {
try {
SIPResponse response = (SIPResponse) evt.getResponse();
String callId = response.getCallIdHeader().getCallId();
if (StringUtils.isBlank(callId)) {
log.warn("Register响应处理失败：callId为空");
return;
}
String toUserId = SipUtils.getUserIdFromToHeader(response);
int statusCode = response.getStatusCode();
if (statusCode == Response.UNAUTHORIZED) {
handleUnauthorizedResponse(evt, toUserId, callId);
} else if (statusCode == Response.OK) {
// 处理注册成功，包括时间同步
handleRegisterSuccess(response, toUserId);
} else {
registerProcessorHandler.handleRegisterFailure(toUserId, statusCode);
log.warn("Register失败：toUserId = {}, statusCode = {}", toUserId, statusCode);
}
} catch (Exception e) {
log.error("处理Register响应异常：evt = {}", evt, e);
}
}
/**
* 处理未授权响应
*
* @param evt 响应事件
* @param toUserId 目标用户ID
* @param callId 呼叫ID
*/
private void handleUnauthorizedResponse(ResponseEvent evt, String toUserId, String callId) {
try {
ResponseEventExt eventExt = (ResponseEventExt) evt;
SIPResponse response = (SIPResponse) evt.getResponse();
// 调用业务处理器
registerProcessorHandler.handleUnauthorized(evt, toUserId, callId);
// 协议层面的重新认证处理
processReAuthentication(eventExt, toUserId, callId);
} catch (Exception e) {
log.error("处理未授权响应异常：toUserId = {}, callId = {}", toUserId, callId, e);
}
}
/**
* 处理重新认证
*
* @param evt 响应事件
* @param toUserId 目标用户ID
* @param callId 呼叫ID
*/
private void processReAuthentication(ResponseEventExt evt, String toUserId, String callId) {
SIPResponse response = (SIPResponse) evt.getResponse();
CallIdHeader callIdHeader = response.getCallIdHeader();
FromDevice fromDevice = deviceSupplier.getClientFromDevice();
ToDevice toDevice = deviceSupplier.getToDevice(deviceSupplier.getDevice(toUserId));
if (fromDevice == null || toDevice == null) {
log.error("设备信息获取失败：fromDevice = {}, toDevice = {}", fromDevice, toDevice);
return;
}
WWWAuthenticateHeader www = (WWWAuthenticateHeader) response.getHeader(WWWAuthenticateHeader.NAME);
if (www == null) {
log.error("未找到WWW-Authenticate头");
return;
}
Integer expire = registerProcessorHandler.getExpire(toUserId);
Request registerRequestWithAuth = SipRequestBuilderFactory.createRegisterRequestWithAuth(
fromDevice, toDevice, callIdHeader.getCallId(), expire, www);
// 发送二次请求
SipSender.transmitRequest(fromDevice.getIp(), registerRequestWithAuth);
log.info("发送重新认证请求：toUserId = {}, callId = {}", toUserId, callId);
}
/**
* 处理注册成功响应，包括时间同步
*
* @param response 注册成功响应
* @param toUserId 目标用户ID
*/
private void handleRegisterSuccess(SIPResponse response, String toUserId) {
try {
// 调用业务处理器
registerProcessorHandler.registerSuccess(toUserId);
log.info("Register成功：toUserId = {}", toUserId);
// 处理SIP校时 - 从Date头域同步时间
handleSipTimeSync(response);
} catch (Exception e) {
log.error("处理注册成功响应异常：toUserId = {}", toUserId, e);
}
}
/**
* 处理SIP校时
*
* @param response SIP响应消息
*/
private void handleSipTimeSync(SIPResponse response) {
try {
DateHeader dateHeader = (DateHeader) response.getHeader(DateHeader.NAME);
if (dateHeader == null) {
log.debug("未找到Date头域，跳过SIP校时");
return;
}
// 获取Date头域的值
Calendar calendar = dateHeader.getDate();
// 将Calendar转换为标准的ISO格式字符串
String dateValue = String.format("%04d-%02d-%02dT%02d:%02d:%02d",
calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH) + 1, // Calendar.MONTH 是从0开始的
calendar.get(Calendar.DAY_OF_MONTH),
calendar.get(Calendar.HOUR_OF_DAY),
calendar.get(Calendar.MINUTE),
calendar.get(Calendar.SECOND));
log.debug("收到Date头域：{}", dateValue);
// 执行时间同步
boolean syncSuccess = timeSyncService.syncTimeFromSip(dateValue);
if (syncSuccess) {
log.info("SIP校时成功");
// 检查是否需要进一步校时
if (timeSyncService.needsTimeSync()) {
log.warn("时间偏差仍然较大，建议检查系统时间设置");
}
} else {
log.warn("SIP校时失败");
}
} catch (Exception e) {
log.error("SIP校时处理异常", e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/register/RegisterProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/register/RegisterProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.register;
import javax.sip.ResponseEvent;
/**
* Register响应处理器业务接口
*
* @author luna
*/
public interface RegisterProcessorHandler {
/**
* 过期时间
*
* @param userId 用户id
* @return second time
*/
default Integer getExpire(String userId) {
return 3600;
}
/**
* 注册成功
*
* @param toUserId 目标用户ID
*/
void registerSuccess(String toUserId);
/**
* 处理未授权响应
*
* @param evt 响应事件
* @param toUserId 目标用户ID
* @param callId 呼叫ID
*/
default void handleUnauthorized(ResponseEvent evt, String toUserId, String callId) {
// 默认实现为空，由业务方根据需要实现
}
/**
* 处理注册失败
*
* @param toUserId 目标用户ID
* @param statusCode 状态码
*/
default void handleRegisterFailure(String toUserId, int statusCode) {
// 默认实现为空，由业务方根据需要实现
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/register/DefaultRegisterProcessorHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/response/register/DefaultRegisterProcessorHandler.java | package io.github.lunasaw.gbproxy.client.transmit.response.register;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* 自定义Register处理器实现
*
* @author luna
*/
@Slf4j
@Component
@ConditionalOnMissingBean(RegisterProcessorHandler.class)
public class DefaultRegisterProcessorHandler implements RegisterProcessorHandler {
@Override
public void registerSuccess(String toUserId) {
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/package-info.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/package-info.java | /**
* SIP客户端接收到请求后的处理
*
* @author luna
* 2021/8/18
*/
package io.github.lunasaw.gbproxy.client.transmit.request;
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/ack/AckRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/ack/AckRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.ack;
import javax.sip.RequestEvent;
/**
* ACK请求业务处理器接口
* 负责处理ACK请求的业务逻辑
*
* @author weidian
*/
public interface AckRequestHandler {
/**
* 处理ACK请求
*
* @param evt ACK请求事件
*/
void processAck(RequestEvent evt);
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/ack/DefaultAckRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/ack/DefaultAckRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.ack;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
/**
* @author luna
* @date 2023/12/29
*/
@Component
@ConditionalOnMissingBean(AckRequestHandler.class)
public class DefaultAckRequestHandler implements AckRequestHandler {
@Override
public void processAck(RequestEvent evt) {
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/ack/ClientAckRequestProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/ack/ClientAckRequestProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.request.ack;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import javax.sip.Dialog;
import javax.sip.DialogState;
import javax.sip.RequestEvent;
import org.springframework.stereotype.Component;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.transmit.event.SipSubscribe;
import io.github.lunasaw.sip.common.transmit.event.request.SipRequestProcessorAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* 客户端ACK请求处理器
* 负责处理客户端收到的ACK请求，专注于协议层面处理
*
* @author weidian
*/
@Component("clientAckRequestProcessor")
@Getter
@Setter
@Slf4j
public class ClientAckRequestProcessor extends SipRequestProcessorAbstract {
private final String METHOD = "ACK";
private String method = METHOD;
@Autowired
@Lazy
private AckRequestHandler ackRequestHandler;
/**
* 处理 ACK请求
*
* @param evt
*/
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest) evt.getRequest();
// 协议层面处理：解析SIP消息
String fromUserId = SipUtils.getUserIdFromFromHeader(request);
String toUserId = SipUtils.getUserIdFromToHeader(request);
log.debug("收到ACK请求: from={}, to={}", fromUserId, toUserId);
// 检查对话状态
Dialog dialog = evt.getDialog();
if (dialog == null) {
log.warn("ACK请求没有关联的对话");
return;
}
if (dialog.getState() == DialogState.CONFIRMED) {
// 发布ACK事件
SipSubscribe.publishAckEvent(evt);
// 调用业务处理器
ackRequestHandler.processAck(evt);
}
} catch (Exception e) {
log.error("处理ACK请求时发生异常: evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/cancel/CancelRequestProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/cancel/CancelRequestProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.request.cancel;
import javax.sip.RequestEvent;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.transmit.event.request.SipRequestProcessorAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 客户端CANCEL请求处理器
* 负责处理客户端收到的CANCEL请求，专注于协议层面处理
*
* @author luna
*/
@Component("clientCancelRequestProcessor")
@Getter
@Setter
@Slf4j
public class CancelRequestProcessor extends SipRequestProcessorAbstract {
private final String METHOD = "CANCEL";
private String method = METHOD;
/**
* 处理CANCEL请求
*
* @param evt 事件
*/
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest) evt.getRequest();
// 协议层面处理：解析SIP消息
String fromUserId = SipUtils.getUserIdFromFromHeader(request);
String toUserId = SipUtils.getUserIdFromToHeader(request);
String callId = SipUtils.getCallId(request);
log.debug("收到CANCEL请求: from={}, to={}, callId={}", fromUserId, toUserId, callId);
// TODO: 实现CANCEL请求的业务逻辑
// 优先级99 Cancel Request消息实现，此消息一般为级联消息，上级给下级发送请求取消指令
} catch (Exception e) {
log.error("处理CANCEL请求时发生异常: evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/invite/DefaultInviteRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/invite/DefaultInviteRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.invite;
import io.github.lunasaw.sip.common.entity.SdpSessionDescription;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* @author luna
* @date 2025/7/13
*/
@Component
@ConditionalOnMissingBean(InviteRequestHandler.class)
public class DefaultInviteRequestHandler implements InviteRequestHandler {
@Override
public void inviteSession(String callId, SdpSessionDescription sessionDescription) {
}
@Override
public String getInviteResponse(String userId, SdpSessionDescription sessionDescription) {
return "";
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/invite/InviteRequestProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/invite/InviteRequestProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.request.invite;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import javax.sip.RequestEvent;
import javax.sip.header.ContentTypeHeader;
import javax.sip.message.Response;
import org.springframework.stereotype.Component;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.entity.GbSessionDescription;
import io.github.lunasaw.sip.common.enums.ContentTypeEnum;
import io.github.lunasaw.sip.common.transmit.ResponseCmd;
import io.github.lunasaw.sip.common.transmit.event.request.SipRequestProcessorAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* SIP命令类型： 收到Invite请求
* 客户端发起Invite请求, Invite Request消息实现，请求视频指令
*
* @author luna
*/
@Component("clientInviteRequestProcessor")
@Getter
@Setter
@Slf4j
public class InviteRequestProcessor extends SipRequestProcessorAbstract {
public static final String METHOD = "INVITE";
private String method = METHOD;
@Autowired
@Lazy
private InviteRequestHandler inviteRequestHandler;
/**
* 收到Invite请求 处理
*
* @param evt
*/
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest) evt.getRequest();
// 协议层面处理：解析SIP消息
String toUserId = SipUtils.getUserIdFromFromHeader(request);
String userId = SipUtils.getUserIdFromToHeader(request);
String callId = SipUtils.getCallId(request);
log.info("📺 客户端收到INVITE请求: callId={}, fromUserId={}, toUserId={}", callId, toUserId, userId);
// 解析Sdp
String sdpContent = new String(request.getRawContent());
GbSessionDescription sessionDescription = (GbSessionDescription) SipUtils.parseSdp(sdpContent);
// 调用业务处理器
inviteRequestHandler.inviteSession(callId, sessionDescription);
String content = inviteRequestHandler.getInviteResponse(userId, sessionDescription);
// 构建响应
ContentTypeHeader contentTypeHeader = ContentTypeEnum.APPLICATION_SDP.getContentTypeHeader();
ResponseCmd.doResponseCmd(Response.OK, "OK", content, contentTypeHeader, evt);
log.info("✅ 客户端INVITE请求处理完成: callId={}", callId);
} catch (Exception e) {
log.error("处理INVITE请求时发生异常: evt = {}", evt, e);
// 发送500错误响应
ResponseCmd.doResponseCmd(Response.SERVER_INTERNAL_ERROR, "Internal Server Error", evt);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/invite/InviteRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/invite/InviteRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.invite;
import io.github.lunasaw.sip.common.entity.SdpSessionDescription;
/**
* INVITE请求业务处理器接口
* 负责处理INVITE请求的业务逻辑
*
* @author weidian
*/
public interface InviteRequestHandler {
/**
* 处理INVITE会话
*
* @param callId 呼叫ID
* @param sessionDescription 会话描述
*/
void inviteSession(String callId, SdpSessionDescription sessionDescription);
/**
* 获取INVITE响应内容
*
* @param userId 用户ID
* @param sessionDescription 会话描述
* @return 响应内容
*/
String getInviteResponse(String userId, SdpSessionDescription sessionDescription);
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/SubscribeHandlerAbstract.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/SubscribeHandlerAbstract.java | package io.github.lunasaw.gbproxy.client.transmit.request.subscribe;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.DeviceSession;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import io.github.lunasaw.sip.common.transmit.event.message.MessageHandlerAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
/**
* @author luna
*/
@Data
@Component
public abstract class SubscribeHandlerAbstract extends MessageHandlerAbstract {
@Autowired
@Lazy
protected SubscribeRequestHandler subscribeRequestHandler;
@Autowired
protected ClientDeviceSupplier clientDeviceSupplier;
public SubscribeHandlerAbstract(@Lazy SubscribeRequestHandler subscribeRequestHandler, ClientDeviceSupplier deviceSupplier) {
this.subscribeRequestHandler = subscribeRequestHandler;
this.clientDeviceSupplier = deviceSupplier;
}
@Override
public String getRootType() {
return SubscribeRequestProcessor.METHOD + "Root";
}
public DeviceSession getDeviceSession(RequestEvent event) {
SIPRequest sipRequest = (SIPRequest) event.getRequest();
// 特别注意：客户端收到消息，fromHeader是服务端，toHeader是客户端
String userId = SipUtils.getUserIdFromToHeader(sipRequest);
String sipId = SipUtils.getUserIdFromFromHeader(sipRequest);
DeviceSession deviceSession = new DeviceSession(userId, sipId);
FromDevice clientFromDevice = clientDeviceSupplier.getClientFromDevice();
if (clientFromDevice != null && clientFromDevice.getUserId().equals(userId)) {
// 如果客户端的fromDevice和请求中的userId一致，说明是自己的设备
deviceSession.setFromDevice(clientFromDevice);
}
Device device = clientDeviceSupplier.getDevice(sipId);
if (device != null) {
ToDevice toDevice = clientDeviceSupplier.getToDevice(device);
deviceSession.setToDevice(toDevice);
}
return deviceSession;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/SubscribeRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/SubscribeRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.subscribe;
import io.github.lunasaw.gb28181.common.entity.query.DeviceQuery;
import io.github.lunasaw.gb28181.common.entity.response.DeviceSubscribe;
import io.github.lunasaw.sip.common.subscribe.SubscribeInfo;
/**
* SUBSCRIBE请求业务处理器接口
* 负责处理SUBSCRIBE请求的业务逻辑
*
* @author luna
* @version 1.0
* @date 2023/12/11
*/
public interface SubscribeRequestHandler {
/**
* 添加订阅信息
*
* @param userId 用户ID
* @param subscribeInfo 订阅信息
*/
void putSubscribe(String userId, SubscribeInfo subscribeInfo);
/**
* 获取设备订阅信息
*
* @param deviceQuery 设备查询
* @return DeviceSubscribe 设备订阅信息
*/
DeviceSubscribe getDeviceSubscribe(DeviceQuery deviceQuery);
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/SubscribeRequestProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/SubscribeRequestProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.request.subscribe;
import javax.sip.RequestEvent;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.transmit.event.message.SipMessageRequestProcessorAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* 客户端SUBSCRIBE请求处理器
* 负责处理客户端收到的SUBSCRIBE请求，专注于协议层面处理
*
* @author luna
*/
@Component("clientSubscribeRequestProcessor")
@Getter
@Setter
@Slf4j
public class SubscribeRequestProcessor extends SipMessageRequestProcessorAbstract {
public static final String METHOD = "SUBSCRIBE";
private String method = METHOD;
@Autowired
private ClientDeviceSupplier clientDeviceSupplier;
/**
* 收到SUBSCRIBE请求 处理
*
* @param evt
*/
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest) evt.getRequest();
// 协议层面处理：解析SIP消息
String fromUserId = SipUtils.getUserIdFromFromHeader(request);
String toUserId = SipUtils.getUserIdFromToHeader(request);
log.debug("收到SUBSCRIBE请求: from={}, to={}", fromUserId, toUserId);
FromDevice clientFromDevice = clientDeviceSupplier.getClientFromDevice();
// 比较 toUserId d和clientFromDevice的userId是否一致 表示收到的消息就是要处理的消息
if (!toUserId.equals(clientFromDevice.getUserId())) {
log.warn("SUBSCRIBE请求的目标用户ID与客户端不匹配: from={}, to={}, clientFromDevice={}", fromUserId, toUserId, clientFromDevice);
return; // 忽略不匹配的请求
}
// 调用消息处理框架
doMessageHandForEvt(evt, clientFromDevice);
} catch (Exception e) {
log.error("处理SUBSCRIBE请求时发生异常: evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/DefaultSubscribeProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/DefaultSubscribeProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.request.subscribe;
import io.github.lunasaw.gb28181.common.entity.query.DeviceQuery;
import io.github.lunasaw.gb28181.common.entity.response.DeviceSubscribe;
import io.github.lunasaw.sip.common.subscribe.SubscribeInfo;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* 默认的 SubscribeRequestHandler 实现
* 提供基本的空实现，业务项目可以自定义实现来覆盖此默认行为
*
* @author luna
* @date 2023/12/29
*/
@Component
@ConditionalOnMissingBean(SubscribeRequestHandler.class)
public class DefaultSubscribeProcessor implements SubscribeRequestHandler {
@Override
public void putSubscribe(String userId, SubscribeInfo subscribeInfo) {
// 默认实现为空，业务项目可以覆盖
}
@Override
public DeviceSubscribe getDeviceSubscribe(DeviceQuery deviceQuery) {
// 默认实现返回null，业务项目可以覆盖
return null;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/catalog/SubscribeCatalogQueryMessageHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/subscribe/catalog/SubscribeCatalogQueryMessageHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.subscribe.catalog;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.gb28181.common.entity.enums.CmdTypeEnum;
import io.github.lunasaw.gb28181.common.entity.query.DeviceQuery;
import io.github.lunasaw.gb28181.common.entity.response.DeviceSubscribe;
import io.github.lunasaw.gbproxy.client.transmit.request.message.MessageRequestHandler;
import io.github.lunasaw.gbproxy.client.transmit.request.subscribe.SubscribeHandlerAbstract;
import io.github.lunasaw.gbproxy.client.transmit.request.subscribe.SubscribeRequestHandler;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.DeviceSession;
import io.github.lunasaw.sip.common.enums.ContentTypeEnum;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import io.github.lunasaw.sip.common.subscribe.SubscribeInfo;
import io.github.lunasaw.sip.common.transmit.ResponseCmd;
import io.github.lunasaw.sip.common.transmit.event.message.MessageHandler;
import io.github.lunasaw.sip.common.utils.SipRequestUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import javax.sip.RequestEvent;
import javax.sip.header.ContentTypeHeader;
import javax.sip.header.EventHeader;
import javax.sip.header.ExpiresHeader;
import javax.sip.message.Response;
/**
* 处理设备通道订阅消息 回复OK
*
* @author luna
* @date 2023/10/19
*/
@Component("subscribeCatalogQueryMessageHandler")
@Slf4j
@Getter
@Setter
public class SubscribeCatalogQueryMessageHandler extends SubscribeHandlerAbstract {
public static final String CMD_TYPE = CmdTypeEnum.CATALOG.getType();
public SubscribeCatalogQueryMessageHandler(@Lazy SubscribeRequestHandler subscribeRequestHandler, ClientDeviceSupplier deviceSupplier) {
super(subscribeRequestHandler, deviceSupplier);
}
@Override
public String getRootType() {
return MessageHandler.QUERY;
}
@Override
public void handForEvt(RequestEvent event) {
DeviceSession deviceSession = getDeviceSession(event);
EventHeader header = (EventHeader) event.getRequest().getHeader(EventHeader.NAME);
if (header == null) {
log.info("handForEvt::event = {}", event);
return;
}
// 订阅消息过来
String sipId = deviceSession.getSipId();
String userId = deviceSession.getUserId();
SIPRequest request = (SIPRequest) event.getRequest();
SubscribeInfo subscribeInfo = new SubscribeInfo(request, sipId);
Device fromDevice = deviceSession.getFromDevice();
if (!userId.equals(fromDevice.getUserId())) {
return;
}
DeviceQuery deviceQuery = parseXml(DeviceQuery.class);
subscribeRequestHandler.putSubscribe(deviceQuery.getDeviceId(), subscribeInfo);
DeviceSubscribe deviceSubscribe = subscribeRequestHandler.getDeviceSubscribe(deviceQuery);
ExpiresHeader expiresHeader = SipRequestUtils.createExpiresHeader(subscribeInfo.getExpires());
ContentTypeHeader contentTypeHeader = ContentTypeEnum.APPLICATION_XML.getContentTypeHeader();
ResponseCmd.sendResponse(Response.OK, deviceSubscribe.toString(), contentTypeHeader, event, expiresHeader);
}
@Override
public String getCmdType() {
return CMD_TYPE;
}
@Override
public boolean needResponseAck() {
return false;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/package-info.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/package-info.java | /**
* SIP客户端接收到MESSAGE类型请求后的处理
*
* @author luna
* 2021/8/18
*/
package io.github.lunasaw.gbproxy.client.transmit.request.message;
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/MessageRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/MessageRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.message;
import io.github.lunasaw.gb28181.common.entity.notify.MobilePositionNotify;
import io.github.lunasaw.gb28181.common.entity.query.*;
import io.github.lunasaw.gb28181.common.entity.response.*;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceAlarmNotify;
import io.github.lunasaw.gb28181.common.entity.notify.DeviceBroadcastNotify;
/**
* MESSAGE请求业务处理器接口
* 负责处理MESSAGE请求的业务逻辑，包括查询、控制、通知等
*
* @author luna
* @date 2023/10/18
*/
public interface MessageRequestHandler {
/**
* 获取设备录像信息
* DeviceRecord
*
* @param deviceRecordQuery 设备录像查询
* @return DeviceRecord 设备录像信息
*/
DeviceRecord getDeviceRecord(DeviceRecordQuery deviceRecordQuery);
/**
* 获取设备状态信息
* DeviceStatus
*
* @param userId 设备Id
* @return DeviceStatus 设备状态信息
*/
DeviceStatus getDeviceStatus(String userId);
/**
* 获取设备信息
* DeviceInfo
*
* @param userId 设备Id
* @return DeviceInfo 设备信息
*/
DeviceInfo getDeviceInfo(String userId);
/**
* 获取设备通道信息
*
* @param userId 设备Id
* @return DeviceResponse 设备通道信息
*/
DeviceResponse getDeviceItem(String userId);
/**
* 处理语音广播通知
*
* @param broadcastNotify 广播通知
*/
void broadcastNotify(DeviceBroadcastNotify broadcastNotify);
/**
* 获取设备告警通知
*
* @param deviceAlarmQuery 告警查询
* @return DeviceAlarmNotify 告警通知
*/
DeviceAlarmNotify getDeviceAlarmNotify(DeviceAlarmQuery deviceAlarmQuery);
/**
* 获取设备配置响应
*
* @param deviceConfigDownload 配置下载查询
* @return DeviceConfigResponse 配置响应
*/
DeviceConfigResponse getDeviceConfigResponse(DeviceConfigDownload deviceConfigDownload);
/**
* 处理设备控制命令
*
* @param deviceControlBase 设备控制基础信息
*/
<T> void deviceControl(T deviceControlBase);
/**
* 获取设备预置位查询应答
*
* @return 预置位查询应答
*/
PresetQueryResponse getDevicePresetQueryResponse(PresetQuery presetQuery);
/**
* 获取设备预置位信息
*
* @param userId 设备Id
* @return 设备预置位应答
*/
PresetQueryResponse getPresetQueryResponse(String userId);
/**
* 获取设备配置查询应答
*
* @param userId 设备Id
* @param configType 配置类型
* @return 设备配置查询应答
*/
ConfigDownloadResponse getConfigDownloadResponse(String userId, String configType);
/**
* 处理设备移动位置通知
*
* @param mobilePositionNotify 移动位置通知
*/
MobilePositionNotify getMobilePositionNotify(MobilePositionQuery mobilePositionQuery);
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/CustomMessageRequestHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/CustomMessageRequestHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.message;
import io.github.lunasaw.gb28181.common.entity.notify.*;
import io.github.lunasaw.gb28181.common.entity.query.*;
import io.github.lunasaw.gb28181.common.entity.response.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.stereotype.Component;
/**
* MESSAGE请求业务处理器默认实现
* 提供默认的业务逻辑处理实现
*
* @author luna
* @date 2023/10/18
*/
@Slf4j
@Component
@ConditionalOnMissingBean(MessageRequestHandler.class)
public class CustomMessageRequestHandler implements MessageRequestHandler {
@Override
public DeviceRecord getDeviceRecord(DeviceRecordQuery deviceRecordQuery) {
log.info("获取设备录像信息: {}", deviceRecordQuery);
return new DeviceRecord();
}
@Override
public DeviceStatus getDeviceStatus(String userId) {
log.info("获取设备状态信息: {}", userId);
return new DeviceStatus();
}
@Override
public DeviceInfo getDeviceInfo(String userId) {
log.info("获取设备信息: {}", userId);
return new DeviceInfo();
}
@Override
public DeviceResponse getDeviceItem(String userId) {
log.info("获取设备通道信息: {}", userId);
return new DeviceResponse();
}
@Override
public void broadcastNotify(DeviceBroadcastNotify broadcastNotify) {
log.info("处理语音广播通知: {}", broadcastNotify);
}
@Override
public DeviceAlarmNotify getDeviceAlarmNotify(DeviceAlarmQuery deviceAlarmQuery) {
log.info("获取设备告警通知: {}", deviceAlarmQuery);
return new DeviceAlarmNotify();
}
@Override
public DeviceConfigResponse getDeviceConfigResponse(DeviceConfigDownload deviceConfigDownload) {
log.info("获取设备配置响应: {}", deviceConfigDownload);
return new DeviceConfigResponse();
}
@Override
public <T> void deviceControl(T deviceControlBase) {
log.info("处理设备控制命令: {}", deviceControlBase);
}
@Override
public PresetQueryResponse getDevicePresetQueryResponse(PresetQuery presetQuery) {
return null;
}
@Override
public MobilePositionNotify getMobilePositionNotify(MobilePositionQuery mobilePositionQuery) {
return null;
}
@Override
public PresetQueryResponse getPresetQueryResponse(String userId) {
log.info("获取设备预置位信息: {}", userId);
return new PresetQueryResponse();
}
@Override
public ConfigDownloadResponse getConfigDownloadResponse(String userId, String configType) {
log.info("获取设备配置查询应答: {}, configType={}", userId, configType);
return new ConfigDownloadResponse();
}
} | java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/ClientMessageRequestProcessor.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/ClientMessageRequestProcessor.java | package io.github.lunasaw.gbproxy.client.transmit.request.message;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import org.springframework.beans.factory.annotation.Autowired;
import javax.sip.RequestEvent;
import org.springframework.stereotype.Component;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.transmit.event.message.SipMessageRequestProcessorAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* 客户端MESSAGE请求处理器
* 负责处理客户端收到的MESSAGE请求，专注于协议层面处理
*
* @author luna
*/
@Component("clientMessageRequestProcessor")
@Getter
@Setter
@Slf4j
public class ClientMessageRequestProcessor extends SipMessageRequestProcessorAbstract {
public static final String METHOD = "MESSAGE";
private String method = METHOD;
@Autowired
private ClientDeviceSupplier clientDeviceSupplier;
@Override
public void process(RequestEvent evt) {
try {
SIPRequest request = (SIPRequest) evt.getRequest();
// 协议层面处理：解析SIP消息
String fromUserId = SipUtils.getUserIdFromFromHeader(request);
String toUserId = SipUtils.getUserIdFromToHeader(request);
log.info("收到MESSAGE请求: from={}, to={}", fromUserId, toUserId);
// 获取FromDevice
FromDevice clientFromDevice = clientDeviceSupplier.getClientFromDevice();
// 比较 toUserId 和 clientFromDevice 的 userId 是否一致 表示收到的消息就是要处理的消息
if (!toUserId.equals(clientFromDevice.getUserId())) {
log.warn("MESSAGE请求的目标用户ID与客户端不匹配: from={}, to={}, clientFromDevice={}", fromUserId, toUserId, clientFromDevice);
return; // 忽略不匹配的请求
}
// 调用消息处理框架
doMessageHandForEvt(evt, clientFromDevice);
} catch (Exception e) {
log.error("处理MESSAGE请求时发生异常: evt = {}", evt, e);
}
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/MessageClientHandlerAbstract.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/MessageClientHandlerAbstract.java | package io.github.lunasaw.gbproxy.client.transmit.request.message;
import javax.sip.RequestEvent;
import io.github.lunasaw.sip.common.entity.Device;
import io.github.lunasaw.sip.common.entity.FromDevice;
import io.github.lunasaw.sip.common.entity.ToDevice;
import io.github.lunasaw.sip.common.service.ClientDeviceSupplier;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import gov.nist.javax.sip.message.SIPRequest;
import io.github.lunasaw.sip.common.entity.DeviceSession;
import io.github.lunasaw.sip.common.transmit.event.message.MessageHandlerAbstract;
import io.github.lunasaw.sip.common.utils.SipUtils;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
/**
* 客户端消息处理器抽象基类
* 提供客户端消息处理的通用功能
*
* @author luna
*/
@Slf4j
@Getter
@Component
@ConditionalOnBean(MessageRequestHandler.class)
public abstract class MessageClientHandlerAbstract extends MessageHandlerAbstract {
@Autowired
public MessageRequestHandler messageRequestHandler;
@Autowired
private ClientDeviceSupplier clientDeviceSupplier;
public MessageClientHandlerAbstract(@Lazy MessageRequestHandler messageRequestHandler) {
this.messageRequestHandler = messageRequestHandler;
}
@Override
public String getRootType() {
return "Root";
}
@Override
public String getMethod() {
return "MESSAGE";
}
/**
* 获取设备会话信息
* 客户端收到消息时，fromHeader是服务端，toHeader是客户端
*
* @param event 请求事件
* @return DeviceSession 设备会话信息
*/
public DeviceSession getDeviceSession(RequestEvent event) {
SIPRequest sipRequest = (SIPRequest)event.getRequest();
// 特别注意：客户端收到消息，fromHeader是服务端，toHeader是客户端
String userId = SipUtils.getUserIdFromToHeader(sipRequest);
String sipId = SipUtils.getUserIdFromFromHeader(sipRequest);
DeviceSession deviceSession = new DeviceSession(userId, sipId);
// 设置FromDevice - 客户端响应时使用
FromDevice clientFromDevice = clientDeviceSupplier.getClientFromDevice();
if (clientFromDevice == null) {
// log 这里获取不到客户端发送设备，表示当前配置未启动客户端，需要抛出异常
throw new RuntimeException("获取不到客户端发送设备，表示当前配置未启动客户端");
}
deviceSession.setFromDevice(clientFromDevice);
// 设置ToDevice - 响应的目标设备（通常是服务端）
Device device = clientDeviceSupplier.getDevice(sipId);
if (device == null) {
// log 这里获取不到目标设备，表示当前配置未启动服务端，需要抛出异常
throw new RuntimeException("获取不到目标设备，表示当前配置未启动服务端");
}
deviceSession.setToDevice(clientDeviceSupplier.getToDevice(device));
return deviceSession;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/handler/BaseMessageClientHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/handler/BaseMessageClientHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.message.handler;
import javax.sip.RequestEvent;
import io.github.lunasaw.gbproxy.client.transmit.request.message.MessageClientHandlerAbstract;
import lombok.Getter;
import lombok.Setter;
import org.springframework.stereotype.Component;
import io.github.lunasaw.gbproxy.client.transmit.request.message.MessageRequestHandler;
import lombok.extern.slf4j.Slf4j;
/**
* 基础消息客户端处理器
* 提供基础的消息处理功能
*
* @author luna
* @date 2023/10/19
*/
@Component
@Slf4j
@Getter
@Setter
public class BaseMessageClientHandler extends MessageClientHandlerAbstract {
public static final String CMD_TYPE = "Catalog";
private String cmdType = CMD_TYPE;
public BaseMessageClientHandler(MessageRequestHandler messageRequestHandler) {
super(messageRequestHandler);
}
@Override
public void handForEvt(RequestEvent event) {
log.info("处理基础消息事件: event = {}", event);
}
@Override
public String getCmdType() {
return cmdType;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
lunasaw/gb28181-proxy | https://github.com/lunasaw/gb28181-proxy/blob/540577abe2124425b68b6288de9e9fc341b1f1fc/gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/handler/query/CatalogQueryMessageClientHandler.java | gb28181-client/src/main/java/io/github/lunasaw/gbproxy/client/transmit/request/message/handler/query/CatalogQueryMessageClientHandler.java | package io.github.lunasaw.gbproxy.client.transmit.request.message.handler.query;
import javax.sip.RequestEvent;
import io.github.lunasaw.gb28181.common.entity.response.DeviceResponse;
import io.github.lunasaw.gbproxy.client.transmit.cmd.ClientCommandSender;
import io.github.lunasaw.gbproxy.client.transmit.request.message.ClientMessageRequestProcessor;
import lombok.Setter;
import org.springframework.stereotype.Component;
import io.github.lunasaw.gbproxy.client.transmit.request.message.MessageClientHandlerAbstract;
import io.github.lunasaw.gbproxy.client.transmit.request.message.MessageRequestHandler;
import io.github.lunasaw.sip.common.entity.DeviceSession;
import io.github.lunasaw.gb28181.common.entity.query.DeviceQuery;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
/**
* 设备目录查询消息处理器
* 负责处理设备目录查询请求
*
* @author luna
* @date 2023/10/19
*/
@Component
@Slf4j
@Getter
@Setter
public class CatalogQueryMessageClientHandler extends MessageClientHandlerAbstract {
public static final String CMD_TYPE = "Catalog";
private String cmdType = CMD_TYPE;
public CatalogQueryMessageClientHandler(MessageRequestHandler messageRequestHandler) {
super(messageRequestHandler);
}
@Override
public String getRootType() {
return "Query";
}
@Override
public void handForEvt(RequestEvent event) {
try {
DeviceSession deviceSession = getDeviceSession(event);
String userId = deviceSession.getUserId();
String sipId = deviceSession.getSipId();
log.debug("处理设备目录查询: userId={}, sipId={}", userId, sipId);
// 解析查询请求
DeviceQuery deviceQuery = parseXml(DeviceQuery.class);
String sn = deviceQuery.getSn();
// 调用业务处理器获取设备目录信息
DeviceResponse deviceResponse = messageRequestHandler.getDeviceItem(userId);
deviceResponse.setSn(sn);
// 发送响应
ClientCommandSender.sendCatalogCommand(deviceSession.getFromDevice(), deviceSession.getToDevice(), deviceResponse);
} catch (Exception e) {
log.error("处理设备目录查询时发生异常: event = {}", event, e);
}
}
@Override
public String getCmdType() {
return cmdType;
}
}
| java | Apache-2.0 | 540577abe2124425b68b6288de9e9fc341b1f1fc | 2026-01-05T02:36:27.870323Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.