java写包走udp/tcp协议发送和接收

最新推荐文章于 2023-12-12 14:46:25 发布
最新推荐文章于 2023-12-12 14:46:25 发布
阅读量508 收藏 4
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leiurse/article/details/114355843
版权

发送包数据的代码

//发送的controller层
package com.rengu.project.integrationoperations.controller;

import com.rengu.project.integrationoperations.configuration.LogConfig;
//import com.rengu.project.integrationoperations.configuration.LogConfig;
import com.rengu.project.integrationoperations.entity.*;
import com.rengu.project.integrationoperations.enums.SystemStatusCodeEnum;
import com.rengu.project.integrationoperations.service.WebSendToCService;
import com.rengu.project.integrationoperations.service.SysErrorLogService;
import com.rengu.project.integrationoperations.service.WebReceiveToCService;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.io.IOUtils;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.validation.constraints.NotNull;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * web端发送到c++端
 *
 * @Author:
 * @Date: 2019/4/12 13:30
 */
@RestController
@RequestMapping(path = "/deployment")
@Slf4j
public class WebSendToCController {
   
	private final WebSendToCService webSendToCService;
	private final WebReceiveToCService receiveInformationService;
	private final SysErrorLogService sysErrorLogService;

	// 设置同批数据为同一序号
	private final int serialNumber = 0;

	@Autowired
	public WebSendToCController(WebSendToCService webSendToCService, WebReceiveToCService receiveInformationService,
								SysErrorLogService sysErrorLogService) {
   
		this.webSendToCService = webSendToCService;
		this.receiveInformationService = receiveInformationService;
		this.sysErrorLogService = sysErrorLogService;

	}

	// 发送系统校时
	@PostMapping("/sendSystemTiming/communication")
	//@LogConfig("发送系统校时")
	public ResultEntity sendSystemTiming(SystemSendTimingCMD systemSendTimingCMD,
										 @NonNull String host, @NonNull String updateAll) throws IOException {
   
		try {
   
			webSendToCService.sendSystemTiming(systemSendTimingCMD, host, updateAll, serialNumber);
		} catch (Exception e) {
   
			// receiveInformationService.receiveSocketHandler1(byteBuffer, host);
			System.out.println("发送系统校时异常");
			SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
			sysErrorLogEntity.setHost(host);
			sysErrorLogEntity.setErrorMsg("发送系统校时异常");
			sysErrorLogEntity.setErrorType("系统校时异常");
			sysErrorLogEntity.setCreateTime(new Date());
			sysErrorLogService.saveError(sysErrorLogEntity);
		}
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, null);
	}

	// 添加定时发送
//	@PostMapping("/addSystemTimingTask/communication")
//	//@LogConfig("添加定时发送")
//	public ResultEntity addSystemTimingTask(String timeNow, String timingPattern, String time, String sendTime,
//											String host, String updateAll) throws SchedulerException {
   
//		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, webSendToCService.addTimeSendTask(timeNow, time, sendTime,
//				timingPattern, host, updateAll, serialNumber));
//	}

	// 设备复位
	@PostMapping("/sendDeviceRestoration/communication")
	public ResultEntity sendDeviceRestoration(DeviceRestorationSendCMD deviceRestorationSendCMD, String host,
											  @NonNull String updateAll) {
   
		try {
   
			webSendToCService.sendDeviceRestoration(deviceRestorationSendCMD, host, updateAll, serialNumber);
		} catch (Exception e) {
   
			System.out.println("设备复位异常");
			SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
			sysErrorLogEntity.setHost(host);
			sysErrorLogEntity.setErrorMsg("发送设备复位异常");
			sysErrorLogEntity.setErrorType("设备复位异常");
			sysErrorLogEntity.setCreateTime(new Date());
			sysErrorLogService.saveError(sysErrorLogEntity);
		}
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
	}

	// 设备自检指令
	@PostMapping("/sendDeviceCheckCMD/communication")
	//@LogConfig("设备自检指令")
	public ResultEntity sendDeviceCheckCMD(DeviceCheckCMD deviceCheckCMD, String host, @NonNull String updateAll) {
   
		try {
   
			webSendToCService.sendDeviceCheckCMD(deviceCheckCMD, host, updateAll, serialNumber);
		} catch (Exception e) {
   
			e.printStackTrace();
			SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
			sysErrorLogEntity.setHost(host);
			sysErrorLogEntity.setErrorMsg("发送设备自检指令异常");
			sysErrorLogEntity.setErrorType("设备自检指令异常");
			sysErrorLogEntity.setCreateTime(new Date());
			sysErrorLogService.saveError(sysErrorLogEntity);
		}
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
	}

	// 软件版本更新
	@PostMapping("/sendSoftwareUpdateCMD/communication")
	//@LogConfig("软件版本更新")
	public ResultEntity sendSoftwareUpdateCMD(String timeNow, String cmd, String softwareID, String host,
											  @NonNull String updateAll) {
   
		try {
   
			webSendToCService.sendSoftwareUpdateCMD(timeNow, cmd, softwareID.trim(), host, updateAll, serialNumber);
		} catch (Exception e) {
   
			System.out.println("软件版本更新异常");
			SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
			sysErrorLogEntity.setHost(host);
			sysErrorLogEntity.setErrorMsg("发送软件版本更新异常");
			sysErrorLogEntity.setErrorType("软件版本更新异常");
			sysErrorLogEntity.setCreateTime(new Date());
			sysErrorLogService.saveError(sysErrorLogEntity);
		}
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
	}

	// 设备网络参数更新指令
	@PostMapping("/sendDeviceNetworkCMD/communication")
	//@LogConfig("设备网络参数更新指令")
	public ResultEntity sendDeviceNetworkCMD(SendDeviceNetWorkParam sendDeviceNetWorkParam, String host,
											 @NonNull String updateAll) {
   
		try {
   
			webSendToCService.sendDeviceNetworkCMD(sendDeviceNetWorkParam, host, updateAll, serialNumber);
		} catch (Exception e) {
   
			// log.info("设备网络参数更新指令异常", e);
			System.out.println("设备网络参数更新指令异常");
			SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
			sysErrorLogEntity.setHost(host);
			sysErrorLogEntity.setErrorMsg("发送设备网络参数更新指令异常");
			sysErrorLogEntity.setErrorType("设备网络参数更新指令异常");
			sysErrorLogEntity.setCreateTime(new Date());
			sysErrorLogService.saveError(sysErrorLogEntity);
		}
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
	}

	// 设备工作流程控制指令
	@PostMapping("/sendDeviceWorkFlowCMD/communication")
	//@LogConfig("设备工作流程控制指令")
	public ResultEntity sendDeviceWorkFlowCMD(DeviceWorkFlowCMD deviceWorkFlowCMD, SystemControlCMD systemControlCMD,
											  Integer count, String host, @NonNull String updateAll) {
   
		try {
   
			webSendToCService.sendDeviceWorkFlowCMD(deviceWorkFlowCMD, systemControlCMD, count, host, updateAll,
					serialNumber);
		} catch (Exception e) {
   
			// log.info("设备工作流程控制指令异常", e);
			System.out.println("设备工作流程控制指令异常");
			SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
			sysErrorLogEntity.setHost(host);
			sysErrorLogEntity.setErrorMsg("发送设备工作流程控制指令");
			sysErrorLogEntity.setErrorType("设备工作流程控制指令");
			sysErrorLogEntity.setCreateTime(new Date());
			sysErrorLogService.saveError(sysErrorLogEntity);
		}
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送控制指令成功");
	}

	// 设备工作流程控制指令(雷达分机指令)(单发,群发)
	@PostMapping("/sendExtensionInstructionsCMD/communication")
	//@LogConfig("设备工作流程控制指令(雷达分机指令)")
	public ResultEntity sendExtensionInstructions(@RequestBody ArrayList<RadarDeviceCMD> deviceWorkFlowCMD,
												  @RequestHeader String deviceHost, @RequestHeader String updateAll) {
   
		if (512 - deviceWorkFlowCMD.size() * 32 < 0) {
   
			return new ResultEntity(SystemStatusCodeEnum.ERROR, "指令条数已超出");
		} else {
   
			try {
   
				webSendToCService.sendExtensionInstructionsCMD(deviceWorkFlowCMD, deviceHost, updateAll, serialNumber);
			} catch (Exception e) {
   
				// e.printStackTrace();
				System.out.println("设备工作流程控制指令(雷达分机指令)");
				SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
				sysErrorLogEntity.setHost(deviceHost);
				sysErrorLogEntity.setErrorMsg("发送设备工作流程控制指令(雷达分机指令)");
				sysErrorLogEntity.setErrorType("设备工作流程控制指令(雷达分机指令)");
				sysErrorLogEntity.setCreateTime(new Date());
				sysErrorLogService.saveError(sysErrorLogEntity);
			}
			return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送雷达分机指令成功");
		}
	}

	// 设备工作流程控制指令(雷达系统指令)(单发,群发)
	@PostMapping("/sendSystemInstructionsCMD/communication")
	//@LogConfig("设备工作流程控制指令(雷达系统指令)")
	public ResultEntity sendSystemInstructions(@RequestBody ArrayList<SystemControlCMD> systemControlCMDs,
											   @RequestHeader String deviceHost, @RequestHeader String updateAll) {
   
		if (512 - systemControlCMDs.size() * 48 < 0) {
   
			return new ResultEntity(SystemStatusCodeEnum.ERROR, "指令条数已超出");
		} else {
   
			try {
   
				webSendToCService.sendSystemInstructionsCMD(systemControlCMDs, deviceHost, updateAll, serialNumber);
			} catch (Exception e) {
   
				System.out.println("设备工作流程控制指令(雷达系统指令)");
				SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
				sysErrorLogEntity.setHost(deviceHost);
				sysErrorLogEntity.setErrorMsg("发送设备工作流程控制指令(雷达系统指令)");
				sysErrorLogEntity.setErrorType("设备工作流程控制指令(雷达系统指令)");
				sysErrorLogEntity.setCreateTime(new Date());
				sysErrorLogService.saveError(sysErrorLogEntity);
			}
			return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送雷达系统指令成功");
		}
	}

	// 敌我系统控制(单发,群发)
	@PostMapping("/sendEnemyAndUsSystemCMD/communication")
	//@LogConfig("敌我系统控制")
	public ResultEntity sendEnemyAndUsCMD(@RequestHeader String deviceHost, @RequestHeader String updateAll,
										  @RequestBody ArrayList<EnemyAndUsCMD> enemyAndUsCMDs) throws IOException {
   
		if (512 - enemyAndUsCMDs.size() * 64 < 0) {
   
			return new ResultEntity(SystemStatusCodeEnum.ERROR, "指令条数已超出");
		} else {
   
			try {
   
				webSendToCService.sendEnemyAndUsCMD(enemyAndUsCMDs, deviceHost, updateAll, serialNumber);
			} catch (Exception e) {
   
				System.out.println("敌我系统控制");
				SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
				sysErrorLogEntity.setHost(deviceHost);
				sysErrorLogEntity.setErrorMsg("发送敌我系统控制");
				sysErrorLogEntity.setErrorType("敌我系统控制");
				sysErrorLogEntity.setCreateTime(new Date());
				sysErrorLogService.saveError(sysErrorLogEntity);
			}

			return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送敌我系统指令成功");
		}
	}

	// 查询所有
	@GetMapping
	public ResultEntity findAll() {
   
		return new ResultEntity(SystemStatusCodeEnum.SUCCESS, receiveInformationService.findAll());
	}
}


//发送的service层
package com.rengu.project.integrationoperations.service;

import com.rengu.project.integrationoperations.entity.*;
import com.rengu.project.integrationoperations.enums.SystemStatusCodeEnum;
import com.rengu.project.integrationoperations.exception.SystemException;
import com.rengu.project.integrationoperations.repository.CMDSerialNumberRepository;
import com.rengu.project.integrationoperations.repository.HostRepository;
import com.rengu.project.integrationoperations.repository.TimingTaskRepository;
import com.rengu.project.integrationoperations.thread.TCPThread;
import com.rengu.project.integrationoperations.util.JsonUtils;
import com.rengu.project.integrationoperations.util.SocketConfig;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.*;

import static com.rengu.project.integrationoperations.util.SocketConfig.BinaryToDecimal;

/**
 * java端发送给c++端
 *
 * @Author: yaojiahao
 * @Date: 2019/4/12 13:32
 */
@Service
@Slf4j
public class WebSendToCService {
   
    private byte backups = 0;
    private final CMDSerialNumberRepository cmdSerialNumberRepository;
    private short shorts = 0;
    private final HostRepository hostRepository;// 当前连接的最大数·
    private final TimingTaskRepository timingTaskRepository;
    private final SchedulerFactoryBean schedulerFactoryBean;
    private SimpMessagingTemplate simpMessagingTemplate;
    DynamicJobService jobService;

    @Autowired
    private SysLogService sysLogService;

    public WebSendToCService(CMDSerialNumberRepository cmdSerialNumberRepository,
                             SchedulerFactoryBean schedulerFactoryBean, TimingTaskRepository timingTaskRepository,
                             HostRepository hostRepository) {
    //

        this.cmdSerialNumberRepository = cmdSerialNumberRepository;
        this.hostRepository = hostRepository;
        this.timingTaskRepository = timingTaskRepository;
//		this.jobService = jobService;
        this.schedulerFactoryBean = schedulerFactoryBean;
    }

    // 系统控制指令帧格式说明（头部固定信息）
    private void sendSystemControlCmdFormat(ByteBuffer byteBuffer, int dataLength, short purPoseAddress,
                                            short sourceAddress, byte regionID, byte themeID, short messageCategory, long sendingDateTime,
                                            int seriesNumber, int packageSum, int currentNum, int dataLengthSum, short version, int retain1,
                                            short retain2) {
   
        // 十六进制转换成十进制
        byteBuffer.putInt(2122389735); // 报文头 7E8118E7
        byteBuffer.putInt(dataLength); // 当前包数据长度
        // 获取当前pid (无法获取目标的pid，暂时拿源地址的PID)
        // String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
        byteBuffer.putShort(shorts); // 目的地址(设备ID号)
        byteBuffer.putShort(sourceAddress); // 源地址(设备ID号)
        byteBuffer.put(regionID); // 域ID(预留)
        byteBuffer.put(themeID); // 主题ID(预留)
        byteBuffer.putShort(messageCategory); // 信息类别号 (各种交换的信息格式报分配唯一的编号)
        // byteBuffer.putLong(getTimes()); // 发报日期时间
        byteBuffer.putLong((long) 0);
        byteBuffer.putInt(seriesNumber); // 序列号 (同批数据的序列号相同，不同批数据的序列号不同)
        byteBuffer.putInt(1); // 包总数 (当前发送的数据，总共分成几个包发送。默认一包)
        byteBuffer.putInt(currentNum); // 当前包号 (当前发送的数据包序号。从1开始，当序列号不同时，当前包号清零，从1开始。)
        byteBuffer.putInt(1536); // 数据总长度
        // 高八位 主版本号 低八位 副版本号 0001 1000
        byteBuffer.putShort((short) 24); // 版本号
        byteBuffer.putInt(retain1); // 保留字段
        byteBuffer.putShort(retain2); // 保留字段
    }

    /**
     * 3.4.6.3 设备自检指令
     *
     * @throws IOException
     */
    public void sendDeviceCheckCMD(DeviceCheckCMD deviceCheckCMD, String host, String updateAll, int serialNumber)
            throws IOException {
   
        // 群发消息
        if (updateAll.equals("1")) {
   
            List<AllHost> list = hostRepository.findAll();
            // 调用序号自增
            int serialNumbers = addSerialNum();
            for (AllHost allHost : list) {
   
                sendDeviceCheckCMD(deviceCheckCMD, allHost.getHost(), "0", serialNumbers);
            }
        } else {
   
            ByteBuffer byteBuffer = ByteBuffer.allocate(84);
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
            // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
            int serialNumber1;
            if (serialNumber == 0) {
   
                serialNumber1 = addSerialNum();
            } else {
   
                serialNumber1 = serialNumber;
            }
            // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
            sendSystemControlCmdFormat(byteBuffer, 84, backups, backups, backups, backups, (short) 12290, 0,
                    serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
            // 报文内容
            byteBuffer.putInt(0); // 信息长度 待定
            byteBuffer.putLong(Long.parseLong(deviceCheckCMD.getTaskFlowNo()));// 任务流水号
            byteBuffer.put(Byte.parseByte(deviceCheckCMD.getCheckType())); // 自检类型

            byteBuffer.putShort(Short.parseShort(deviceCheckCMD.getCheckPeriod())); // 自检周期
            byte num = (byte) (Integer.parseInt(deviceCheckCMD.getCheckNum()));
            byteBuffer.put(num); // 自检数量
            byteBuffer.putInt(Integer.parseInt(deviceCheckCMD.getSingleMachineCode())); // 自检单机代码
            // 雷达
            byteBuffer.putShort(Short.parseShort(deviceCheckCMD.getRadarSelfChecking())); // 自检频率
            byteBuffer.put(Byte.parseByte(deviceCheckCMD.getRadarBranChoose()));// 带宽选择
            byteBuffer.put(Byte.parseByte(deviceCheckCMD.getRadarSelfChoose()));// 自检模式选择
            // 敌我
            byteBuffer.putShort(Short.parseShort(deviceCheckCMD.getEnemyAndUsSelfChecking())); // 自检频率
            byteBuffer.put(Byte.parseByte(deviceCheckCMD.getEnemyAndUsBranChoose()));// 带宽选择
            byteBuffer.put(Byte.parseByte(deviceCheckCMD.getEnemyAndUsSelfChoose()));// 自检模式选择

            byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
            // 帧尾
            getBigPackageTheTail(byteBuffer);
            // 发送信息
            sendMessage(host, byteBuffer);
            SysLogEntity sysLogEntity = new SysLogEntity();
            String action = JsonUtils.toJson(deviceCheckCMD);
            sysLogEntity.setUserAction("设备自检");
            sysLogEntity.setActionDescription(action);
            sysLogEntity.setCreateTime(new Date());
            sysLogEntity.setHost(host);
            sysLogService.saveLog(sysLogEntity);
        }
    }

    /**
     * 3.4.6.4 系统校时指令
     *
     * @throws IOException
     */
    public void sendSystemTiming(SystemSendTimingCMD systemSendTimingCMD, String host, String updateAll,
                                 int serialNumber) throws IOException {
   
        if (updateAll.equals("1")) {
   
            List<AllHost> list = hostRepository.findAll();
            int serialNumbers = addSerialNum();
            for (AllHost allHost : list) {
   
                sendSystemTiming(systemSendTimingCMD, allHost.getHost(), "0", serialNumbers);
            }
        } else {
   
            ByteBuffer byteBuffer = ByteBuffer.allocate(77);
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
            // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
            int serialNumber1;
            if (serialNumber == 0) {
   
                serialNumber1 = addSerialNum();
            } else {
   
                serialNumber1 = serialNumber;
            }
            // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
            sendSystemControlCmdFormat(byteBuffer, 77, shorts, shorts, backups, backups, (short) 12291, 0,
                    serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
            // 报文内容
            byteBuffer.putInt(1); // 信息长度
            byteBuffer.putLong(Long.parseLong(systemSendTimingCMD.getTimeNow()));
            byteBuffer.put(Byte.parseByte(systemSendTimingCMD.getTimingPattern()));
            byteBuffer.putLong(Long.parseLong(systemSendTimingCMD.getTime()));
            byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
            getBigPackageTheTail(byteBuffer);
            // 发送信息
            sendMessage(host, byteBuffer);
            // 发送系统校时指令日志
            SysLogEntity sysLogEntity = new SysLogEntity();
            String str = JsonUtils.toJson(systemSendTimingCMD);
            sysLogEntity.setUserAction("系统校时指令");
            sysLogEntity.setActionDescription(str);
            sysLogEntity.setCreateTime(new Date());
            sysLogEntity.setHost(host);
            sysLogService.saveLog(sysLogEntity);
        }
    }

    /**
     * 3.4.6.5 设备复位
     *
     * @throws IOException
     */
    public void sendDeviceRestoration(DeviceRestorationSendCMD deviceRestorationSendCMD, String host, String updateAll,
                                      int serialNumber) throws IOException {
   
        if (updateAll.equals("1")) {
   
            List<AllHost> list = hostRepository.findAll();
            int serialNumbers = addSerialNum();
            for (AllHost allHost : list) {
   
                try {
   
                    sendDeviceRestoration(deviceRestorationSendCMD, allHost.getHost(), "0", serialNumbers);
                } catch (Exception e) {
   
                    // TODO: handle exception
                    e.printStackTrace();
                }

            }
        } else {
   
            ByteBuffer byteBuffer = ByteBuffer.allocate(69);
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
            // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
            int serialNumber1;
            if (serialNumber == 0) {
   
                serialNumber1 = addSerialNum();
            } else {
   
                serialNumber1 = serialNumber;
            }
            // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
            sendSystemControlCmdFormat(byteBuffer, 69, shorts, shorts, backups, backups, (short) 12292, 0,
                    serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
            // 报文内容
            byteBuffer.putInt(1); // 信息长度
            byteBuffer.putLong(Long.parseLong(deviceRestorationSendCMD.getTimeNow())); // 任务流水号
            byteBuffer.put(Byte.parseByte(deviceRestorationSendCMD.getExecutePattern())); // 执行方式
            byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
            getBigPackageTheTail(byteBuffer);
            // 发送信息
            sendMessage(host, byteBuffer);
            // 记录操作日
            String type = JsonUtils.toJson(deviceRestorationSendCMD);
            SysLogEntity sysLogEntity = new SysLogEntity();
            sysLogEntity.setUserAction("远程开关机指令");
            sysLogEntity.setCreateTime(new Date());
            sysLogEntity.setHost(host);
            sysLogEntity.setActionDescription(type);
            sysLogService.saveLog(sysLogEntity);
        }
    }

    /**
     * 3.4.6.6 软件版本远程更新
     *
     * @throws IOException
     */
    public void sendSoftwareUpdateCMD(String timeNow, String cmd, String softwareID, String host, String updateAll,
                                      int serialNumber) throws IOException {
   
        if (updateAll.equals("1")) {
   
            List<AllHost> list = hostRepository.findAll();
            int serialNumbers = addSerialNum();
            for (AllHost allHost : list) {
   
                sendSoftwareUpdateCMD(timeNow, cmd, softwareID, allHost.getHost(), "0", serialNumbers);
            }
        } else {
   
            ByteBuffer byteBuffer = ByteBuffer.allocate(72);
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
            // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
            int serialNumber1;
            if (serialNumber == 0) {
   
                serialNumber1 = addSerialNum();
            } else {
   
                serialNumber1 = serialNumber;
            }
            // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
            sendSystemControlCmdFormat(byteBuffer, 72, shorts, shorts, backups, backups, (short) 12293, 0,
                    serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
            // 报文内容
            byteBuffer.putInt(2); // 信息长度
            byteBuffer.putLong(Long.parseLong(timeNow)); // 任务流水号
            byteBuffer.putShort(Short.parseShort(cmd)); // 指令操作码
            byteBuffer.putShort(Short.parseShort(softwareID)); // 软件ID号
            byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
            getBigPackageTheTail(byteBuffer);
            // 发送信息
            sendMessage(host, byteBuffer);
        }
    }

    /**
     * 3.4.6.7 设备网络参数更新指令
     *
     * @throws IOException
     */
    public void sendDeviceNetworkCMD(SendDeviceNetWorkParam sendDeviceNetWorkParam, String host, String updateAll,
                                     int serialNumber) throws IOException {
   
        if (updateAll.equals("1")) {
   
            List<AllHost> list = hostRepository.findAll();
            int serialNumbers = addSerialNum();
            for (AllHost allHost : list) {
   
                sendDeviceNetworkCMD(sendDeviceNetWorkParam, allHost.getHost(), "0", serialNumbers);
            }
        } else {
   
            ByteBuffer byteBuffer = ByteBuffer.allocate(156);
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
            // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
            int serialNumber1;
            if (serialNumber == 0) {
   
                serialNumber1 = addSerialNum();
            } else {
   
                serialNumber1 = serialNumber;
            }
            // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
            sendSystemControlCmdFormat(byteBuffer, 156, shorts, shorts, backups, backups, (short) 12294, 0,
                    serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
            // 报文内容
            byteBuffer.putInt(3); // 信息长度
            byteBuffer.putLong(Long.parseLong(sendDeviceNetWorkParam.getTaskFlowNo())); // 任务流水号
            byteBuffer.putShort(Short.parseShort(sendDeviceNetWorkParam.getCmd())); // 指令操作码
            byteBuffer.putShort(Short.parseShort(sendDeviceNetWorkParam.getNetworkID())); // 网络终端ID号

            // 1
            String networkIP1 = sendDeviceNetWorkParam.getNetworkIP1();
            byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP1)));
            byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP1()));// MAC地址1
            byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage1())); // 网络端口信息1

            // 2
            // byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP2()));
            // // 网络IP地址2
            String networkIP2 = sendDeviceNetWorkParam.getNetworkIP2();
            byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP2)));
            byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP2()));// MAC地址2
            byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage2())); // 网络端口信息2

            // 3
            // byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP3()));
            // // 网络IP地址3
            String networkIP3 = sendDeviceNetWorkParam.getNetworkIP3();
            byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP3)));
            byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP3()));// MAC地址3
            byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage3())); // 网络端口信息3

            // 4
            // byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP4()));
            // // 网络IP地址4
            String networkIP4 = sendDeviceNetWorkParam.getNetworkIP4();
            byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP4)));
            byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP4()));// MAC地址4
            byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage4())); // 网络端口信息4

            // 5
            // byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP5()));
            // // 网络IP地址5
            String networkIP5 = sendDeviceNetWorkParam.getNetworkIP5();
            byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP5)));
            byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP5()));// MAC地址5
            byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage5())); // 网络端口信息5

            // 6
            // byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP6()));
            // // 网络IP地址6
            String networkIP6 = sendDeviceNetWorkParam.getNetworkIP6();
            byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP6)));
            byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP6()));// MAC地址6
            byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage6())); // 网络端口信息6
            byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
            getBigPackageTheTail(byteBuffer);
            // 发送信息
            sendMessage(host, byteBuffer);
        }
    }

    /**
     * 3.4.6.8 设备工作流程控制指令
     *
     * @throws IOException
     */
    public void sendDeviceWorkFlowCMD(DeviceWorkFlowCMD deviceWorkFlowCMD, SystemControlCMD systemControlCMD,
                                      Integer count, String host, String updateAll, int serialNumber) throws IOException {
   
        if (updateAll.equals("1")) {
   
            List<AllHost> list = hostRepository.findAll();
            int serialNumbers = addSerialNum();
            for (AllHost allHost : list) {
   
                sendDeviceWorkFlowCMD(deviceWorkFlowCMD, systemControlCMD, count, allHost.getHost(), "0",
                        serialNumbers);
            }
        } else {
   
            ByteBuffer byteBuffer = ByteBuffer.allocate(1094);// 1094
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
            // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
            int serialNumber1;
            if (serialNumber == 0) {
   
                serialNumber1 = addSerialNum();
            } else {
   
                serialNumber1 = serialNumber;
            }
            // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
            sendSystemControlCmdFormat(byteBuffer, 1094, shorts, shorts, backups, backups, (short) 12295, 0,
                    serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
            // 报文内容
            byteBuffer.putInt(1); // 信息长度
            byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getTaskFlowNo())); // 任务流水号
            byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getCmd())); // 指令有效标记
            // 分机控制指令（雷达侦查指令）
            for (int i = 1; i <= count; i++) {
   
                byteBuffer.putShort(SocketConfig.header); // 包头
                byte pulse = Byte.parseByte(deviceWorkFlowCMD.getPulse()); // 内外秒脉冲选择
                byteBuffer.put(pulse);
                byteBuffer.put(backups); // 备份
                // 分机控制字
                byte[] con = extensionControl(deviceWorkFlowCMD.getExtensionControlCharacter());
                byteBuffer.put(con[0]);
                byteBuffer.put(con[1]);
                byteBuffer.put(backups); // 备份
                byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getThreshold())); // 检测门限调节
                byteBuffer.putShort((Short.parseShort(deviceWorkFlowCMD.getOverallpulse())));// 上传脉冲数
                byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getMinamplitude()));// 最小幅度
                byte c = (byte) (Integer.parseInt(deviceWorkFlowCMD.getMaxamplitude()) & 0xff);
                byteBuffer.put(c);// 最大幅度
                byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getMinPulsewidth()));// 最小脉宽
                byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getMaxPulsewidth()));// 最大脉宽
                byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getFilterMaximumFrequency()));// 筛选最大频率
                byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getFilterMinimumFrequency()));// 筛选最小频率
                byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getShieldingMaximumFrequency()));// 屏蔽最大频率
                byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getShieldingMinimumFrequency()));// 屏蔽最小频率
                // 默认值更新标记
                if (deviceWorkFlowCMD.getDefalutUpdate().equals("0")) {
   
                    byteBuffer.put((byte) 0);
                } else if (deviceWorkFlowCMD.getDefalutUpdate().equals("1")) {
   
                    byteBuffer.put((byte) 1);
                }
                byteBuffer.putShort(shorts); // 备份
                byteBuffer.put(backups); // 备份
                byteBuffer.putShort(shorts); // 备份
                // 小包尾
                getPackageTheTail(byteBuffer);
                // 雷达系统控制指令
                byteBuffer.putShort(SocketConfig.header);// 包头1ACF
                byteBuffer.put(Byte.parseByte(systemControlCMD.getWorkPattern()));// 工作模式
                byteBuffer.put(Byte.parseByte(systemControlCMD.getWorkPeriod())); // 工作周期
                byteBuffer.putShort(Short.parseShort(systemControlCMD.getWorkPeriodNum()));// 工作周期数
                byteBuffer.putShort(Short.parseShort(systemControlCMD.getInitialFrequency())); // 起始频率
                byteBuffer.putShort(Short.parseShort(systemControlCMD.getTerminationFrequency())); // 终止频率
                byteBuffer.putShort(Short.parseShort(systemControlCMD.getSteppedFrequency()));// 频率步进
                byteBuffer.put(Byte.parseByte(systemControlCMD.getBandWidthSelection()));// 带宽选择
                byteBuffer.putShort(shorts);// 备份
                byteBuffer.put(backups); // 备份
                byteBuffer.put(Byte.parseByte(systemControlCMD.getAntennaSelection1()));// 天线1选择(页面不展示)
                byteBuffer.put(Byte.parseByte(systemControlCMD.getAntennaSelection2()));// 天线2选择(页面不展示)
                byteBuffer.putShort(shorts);// 备份
                // 射频一衰减(最新要求改成射频2：6-18Hz射频衰减1)
                // 0:不衰减 1：衰减30db
                if (systemControlCMD.getRadioFrequencyAttenuation2().equals("0")) {
   
                    byteBuffer.put((byte) 0);
                } else if (systemControlCMD.getRadioFrequencyAttenuation2().equals("1")) {
   
                    byteBuffer.put((byte) 1);
                }
                // 射频一长电缆均衡衰减控制
//				StringBuilder stringBuilders = new StringBuilder();
//				String balancedAttenuationRF1 = stringBuilders.reverse()
//						.append(systemControlCMD.getAttenuationControl1()).toString();
//				byte bytesAttenuationRF1 = (byte) BinaryToDecimal(Integer.parseInt(balancedAttenuationRF1));
//				byteBuffer.put(bytesAttenuationRF1);
                byteBuffer.put(backups); // 射频一长电缆均衡衰减控制
                byteBuffer.putShort(shorts); // 备份
                // 射频二衰减(改名为射频1：6-18Hz射频衰减)
                // 射频一衰减(最新要求改成射频2：6-18Hz射频衰减)
                // 0:不衰减 1：衰减30db
                if (systemControlCMD.getRadioFrequencyAttenuation1().equals("0")) {
   
                    byteBuffer.put((byte) 0);
                } else if (systemControlCMD.getRadioFrequencyAttenuation1().equals("1")) {
   
                    byteBuffer.put((byte) 1);
                }
                // 射频二长电缆均衡衰减控制(最新)
//				StringBuilder stringBuilderAttenuationRF2 = new StringBuilder();
//				String balancedAttenuationRF2 = stringBuilderAttenuationRF2.reverse()
//						.append(systemControlCMD.getAttenuationControl2()).toString();
//				byte bytesAttenuationRF2 = (byte) BinaryToDecimal(Integer.parseInt(balancedAttenuationRF2));
//				byteBuffer.put(bytesAttenuationRF2);
                byteBuffer.put(backups);// 射频二长电缆均衡衰减控制
                byteBuffer.putShort(shorts);
                // (最新为中频2衰减0.5dB)
                byte mid2 = (byte) ((byte) Double.parseDouble(systemControlCMD.getMidCut2()) * 0.5);
                byteBuffer.put(mid2); // 中频衰减1
                byteBuffer.putShort(shorts); // 备份
                byteBuffer.put(backups);
                // 中频1衰减(最新)
                byte mid1 = (byte) ((byte) Double.parseDouble(systemControlCMD.getMidCut1()) * 0.5);
                byteBuffer.put(mid1);
                // 衰减码控制方式
                byteBuffer.put(Byte.parseByte(systemControlCMD.getAttenuationCodeControlMode()));
                // 自检模式选择
                byteBuffer.put(Byte.parseByte(systemControlCMD.getRadarSelfChoose()));
                // 备份
                byteBuffer.put(backups);
                // 自检源衰减
                byteBuffer.put(Byte.parseByte(systemControlCMD.getSelfCheckingSourceAttenuation()));
                // 脉内引导批次开关
                byteBuffer.put(Byte.parseByte(systemControlCMD.getBatchNumberSwitch()));
                // 脉内引导批次号
                byteBuffer.put(backups);
                // byteBuffer.put(Byte.parseByte(systemControlCMD.getBatchNumber()));
                // 故障检测门限
                byteBuffer.put(Byte.parseByte(systemControlCMD.getFaultDetectionThreshold()));
                // 定时时间码

                // 转换2进制
                // 定时时间码
                String time = systemControlCMD.getTimingTimeCode();
                // 转换月
                String monthString = time.substring(0, 2);
                // 转换日
                String dayString = time.substring(2, 4);
                // 转换时
                String hourString = time.substring(4, 6);
                // 转换分
                String minString = time.substring(6, 8);
                // 转换秒
                String secondString = time.substring(8, 10);

                // 转2进制月
                String monthBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(monthString));
                int monthLeftNum = 4 - monthBinaryString.length();
                for<
最低0.47元/天 解锁文章
leisure~
关注
TCP/IP协议详解
王佳斌
05-11 38万+
认识HTTP协议 它是互联网协议(Internet Protocol Suite)，一个网络通信模型，是互联网的一个基本的构架。 HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。 HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件...
java使用udp协议和硬件进行数据收发处理
09-20
java使用udp协议进行数据收发处理，java使用udp协议进行数据收发处理
java udp发送接收数据_Java NIO实例UDP发送接收数据代码分享
weixin_39914825的博客
02-13 194
Java的NIO包中，有一个专门用于发送UDP数据包的类：DatagramChannel，UDP是一种无连接的网络协议，一般用于发送一些准确度要求不太高的数据等。完整的服务端程序如下：public class StatisticsServer {//每次发送接收的数据包大小private final int MAX_BUFF_SIZE = 1024 * 10;//服务端监听端口，客户端也通过该端口...
java发送自定义数据包_java-ACRA发送自定义数据REPORTFIELD
weixin_27972919的博客
02-26 107
如何使用Couchdb配置CUSTOM_DATA字段？我想设置一个配置值与错误一起发送.在后端,我有一个带有ACLARYZER Web应用程序的沙发数据库.这是我在Android的Application.class上定义此自定义数据值的代码.@ReportsCrashes(formUri = "https://user.cloudant.com/acra-report/_design/acra-s...
udp协议接收数据Java_Java_网络编程_使用UDP协议发送及接收数据
weixin_40002336的博客
02-27 96
package test;import java.io.IOException;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;public class UDPSender {public static void main(String[] args) throws ...
Java教程：如何基于Tcp/Ip协议发送Socket请求并接收响应
wfeil211的博客
08-31 2454
如何基于Tcp/Ip协议发送Socket请求并接收响应
C# UDP/TCP协议 网络调试工具源码
12-26
【C# UDP/TCP协议 网络调试工具源码】是针对网络编程初学者的宝贵资源，它包含了使用C#语言实现的TCP和UDP协议的客户端与服务端示例。通过学习和研究这些源码，你可以深入理解这两种常用网络传输协议的工作原理，并...
UDP和TCP发送接收数据(java)
m0_53547710的博客
09-20 815
用户数据报协议（User Dategram protocol）UDP是无连接通信协议，即在数据传输时，数据接收端和数据接收端不会建立逻辑连接。简单来说，当一台计算机向另一台计算机发送数据时，发送端不会确认接收端是否存在，就会发送数据，同时接收端在收到数据时，也不会向发送端反馈是否接收到数据由于使用UDP协议消耗资源少，通讯效率高，所以通常都会用于音频，视频和普通数据的传输（优点）例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。
【测试】echo发送和接收TCP/UDP数据包|shell 发送TCP/UDP数据包
小鱼菜鸟的博客
07-22 2658
目录 通过/dev/tcp、/dev/udp shell给tcp或udp服务发送16进制报文指令 shell处理进制数和字节 shell 10进制转16进制数 十六进制字符串到字节 shell字符串倒叙 shell判断大小端序 通过/dev/tcp、/dev/udp (Linux shell脚本中发起tcp、udp连接_Blue su...
tcp_udp_socket.zip_Java TCP/UDP_java Tcp _java socket _java tcp
09-23
`DatagramSocket`类代表一个UDP套接字，可以发送和接收数据报。`DatagramPacket`用来封装要发送的数据和目标地址，或者接收来自特定源的数据报。 "UDPServer.java"文件应展示了UDP服务器端的实现，它创建一个`...
java UDP报文的发送与接收
06-21
java UDP报文的发送与接收 java UDP报文的发送与接收 java UDP报文的发送与接收
用java写的tcp数据包发送和接收代码
04-07
用java写的tcp数据包发送和接收代码,客户端与服务端测试代码
Java中的TCP发送和接收数据
feizuiku0116的博客
01-06 5888
一、发送数据 一、Java中的TCP通信 Java对基于TCP协议的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信 Java为客户端提供了Socket类，为服务器端提供了ServerSocket类 二、构造方法 Socket(InetAddress address,int port)：创建流套接字并将其连接到指定IP指定端口号 Socket(String host,int port)：创建流套接字并将其连接到指定主机上的指定端口号 三、相关
JAVA TCP协议的发送接收
清风地带
09-19 5640
import java.net.*;import java.io.*;import java.util.*;public class Tcp{ public void receiver(int port)    {  ServerSocket serveSocket = null;  Socket clientSocket = null;  BufferedInputStream inpu
tcp header java_解析Tcp协议包头
weixin_39915668的博客
02-22 673
解析Tcp协议包头(包头：0x7R7R1E1E)个人体会首先tcp协议的数据传输是一个数据流，也就是像水管一样的，一头是我们的水井，一头是用水的人，比如我们想要500L水，这时候打开水龙头，水是通过水管流出来的，在需要很多水的时候，我们需要慢慢的接，不可能一下子就有我们的500L期望量。代码首先自己也是学习的情况下，写下自己的心得，有错误的望提出，互相提升。下面展示一些 找头0x7R7R1E1E。...
Java udp协议进行传输数据
王宁的博客
01-31 1590
Java中对使用UDP协议进行传输的数据，使用DategramSocket和DatagramPacket两个类来进行处理，其实挺简单的，在这里进行一个学习之后的总结。 发送端的代码： public class Send { public static void main(String[] args) throws IOException { DatagramSoc
Java：TCP 通信方法（基本发送 + 接收）并 实现文件传输且反馈
最新发布
Cosmoshhhyyy的博客
12-12 2133
本文包含，java的TCP编程的基本用法，并实现文件传输且反馈。
Java 网络编程TCP协议之发送数据和接收数据的详解
热门推荐
路宇的博客
11-27 1万+
TCP协议: 传输控制协议(Transmission Control Protocol) TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端和服务器端，由客户端向服务器端发出连接请求，每次连接的创建都要经历“三次握手”。 三次握手： TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。 第一握手，客户端向服务器发出连接请求，等待服务器确认。 第二次握手，服务
java 读取硬件设备发送数据_Java网络编程基础
weixin_32207065的博客
12-26 2183
1、软件结构C/S结构：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。B/S结构：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。2、网络通信协议UDP：用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值