广告调度中心

最新推荐文章于 2024-11-17 21:07:59 发布
最新推荐文章于 2024-11-17 21:07:59 发布
阅读量131 收藏
点赞数
分类专栏： 并发编程 文章标签： java json runtime
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_4064/article/details/82568947
版权

背景介绍

      一支广告的投放通常有很多的限定条件：地域、时段、频次、广告位、轮播顺序、用户标签【性别、年龄、爱好】。广告主的期望有良好的投放效果，广告平台期望有良好的投放量以及效果。假设媒体资源足够，那我们应该需要计算出每一分钟应该完成的投放量，调度就是为了完成这个目标。

 

调度需要的数据

  • 容量曲线
  • 分钟级别的排期
  • 总的投放量
  • 已经完成的数据量

 

计算公式

  • 本分钟应该完成的量=(总的投放量-已完成量)*容量因子
  • 容量因子=当前分钟容量/剩余排期容量 [计算过程数据完全依赖容量曲线]

 

 

已经完成的量

      获取这个数据的方式有很多种方式，我们这里通过广告投放机器提供的接口获得，调度中心只按照自己的策略获取即可，由于投放机器有很多我们需要并发获取数据来加快整个调度的过程。通过CountDownLatch来控制是否完成了所有机器都的收账。

 

收账代码

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

import net.sf.json.JSONArray;
import net.sf.json.JSONException;
import net.sf.json.JSONObject;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;

import com.javagc.entity.ErrorStackMessage;
import com.javagc.entity.MergePolicy;
import com.javagc.context.CollectEffectDataContext;
import com.javagc.context.ServerGroupContext.GROUPS;
import com.javagc.entity.CollectEffectData;
import com.javagc.entity.CollectRunStatus;
import com.javagc.entity.CollectTaskDTO;
import com.javagc.entity.CurrCastData.DELIVER_TYPE;
import com.javagc.service.IEffectCollectService;
import com.javagc.util.DispatcherConstants;
import com.javagc.util.DispatcherUtil;

/**
 * 任务 stevenDing<br>
 */
public class CollectTask implements Runnable {

	private static final Logger logger = DispatcherUtil.getLog();
	
	private CollectEffectData 			  collectEffectData;
	private Map<String, CollectRunStatus> runStatusMap;
	private CountDownLatch 		 latch;
	private IEffectCollectService collect;
	private CollectTaskDTO 		 taskDTO;
	private GROUPS  			 group;

	// shared data
	private int 		generateJsonCost;
	private String 		result;
	private boolean 	runStatus;
	private long 		endTime;
	private List<Long> 	reTryRunTimeList = new ArrayList<Long>();
	
	/**
	 * 
	 * @param taskDTO
	 * @param effectData
	 * @param runLogMap
	 * @param latch
	 * @param collect
	 */
	public EffectCollectTask(	CollectTaskDTO 		taskDTO, 
								CollectEffectData 	collectEffectData,
								Map<String, CollectRunStatus> runStatusMap, 
								CountDownLatch 			latch,
								IEffectCollectService 	collect,
								GROUPS  group) {
		
		this.taskDTO 			= taskDTO;
		this.collectEffectData 	= collectEffectData;
		this.runStatusMap 		= runStatusMap;
		this.latch 				= latch;
		this.collect 			= collect;
		this.group				= group;
	}

	public void run() {

		try {
			// retry it
			while (true) {
				// invoke effect data
				long retryBegin = System.currentTimeMillis();
				try {
					invokeEffectData();
					runStatus = true;
				} catch (Throwable e) {
					runStatus = false;
					logger.error(e.getMessage(), e);
					ErrorStackMessage msg = new ErrorStackMessage(e, "", new MergePolicy(false,true));
					DispatcherConstants.collectErrorStackCollector.produce(msg);
				} finally {
					reTryRunTimeList.add(System.currentTimeMillis() - retryBegin);
				}
				
				//任务剩余时间
				long remainingTime = (taskDTO.getBeginTime() + taskDTO.getTimeout()) - System.currentTimeMillis();

				//成功或剩余时间不足则退出收账
				if (isRunStatus()|| 
					remainingTime < DispatcherConstants.COLLECTOR_BREAKTIME) {
					break;
				}else{
					try{
						Thread.sleep(DispatcherConstants.COLLECTOR_RETRYSLEEPMS);
					}catch(Exception e){}
				}
			}
		} finally {
			try {
				if (taskDTO.getClient() != null) {
					taskDTO.getClient().getConnectionManager().shutdown();
				}
			} catch (Throwable e) {
				logger.error(e.getMessage(), e);
				ErrorStackMessage msg = new ErrorStackMessage(e, "", new MergePolicy(false,true));
				DispatcherConstants.collectErrorStackCollector.produce(msg);
			}
		}

		try {
			// invoke succ
			if (isRunStatus()) {
				parseEffectData();
				CollectEffectDataContext.I.updateCollectEffectData(group,collectEffectData);
				runStatus = true;
			}
		} catch (Throwable e) {
			logger.error(e.getMessage(), e);
			ErrorStackMessage msg = new ErrorStackMessage(e, "", new MergePolicy(false,true));
			DispatcherConstants.collectErrorStackCollector.produce(msg);
			runStatus = false;
		} finally {
			try {
				endTime = System.currentTimeMillis();
				CollectRunStatus runStatus = wrapperRunStatus();
				// check main thread status
				if (!collect.isCollectCompleted()) {
					runStatusMap.put(taskDTO.getIp(), runStatus);
				}
			} catch (Throwable e) {
				logger.error(e.getMessage(), e);
				ErrorStackMessage msg = new ErrorStackMessage(e, "", new MergePolicy(false,true));
				DispatcherConstants.collectErrorStackCollector.produce(msg);
			}
			latch.countDown();
		}
	}

	protected void invokeEffectData() throws ClientProtocolException, IOException {
		HttpResponse response = taskDTO.getClient().execute(taskDTO.getGet());
		HttpEntity entity = response.getEntity();
		if (entity != null) {
			result = EntityUtils.toString(entity, "UTF-8");
		}
	}

	/**
	 * json --> {"cost" : 34,"s" : [{"id" : 111, "t" : 58},{"id" : 222,"t" : 66}],
	 * "c" : [{"id" : 10, "t" : 23},{"id" : 15,"t" : 39}],"vs" : [{"id" : 20, "t" : 13},{"id" : 45,"t" : 22}],
	 *   "ps" : [{"id" : 30, "t" : 42},{"id" : 37,"t" : 18}]} 
	 */
	protected void parseEffectData() throws Exception {
		
		JSONObject object = JSONObject.fromObject(getResult());
		// cost time
		generateJsonCost = object.getInt("cost");		
		parseEffectData(DELIVER_TYPE.CPM, object, "s");
		parseEffectData(DELIVER_TYPE.CPC, object, "c");
		parseEffectData(DELIVER_TYPE.CPV, object, "vs");
		parseEffectData(DELIVER_TYPE.CPP, object, "ps");
	}
	
	/**
	 * 
	 * @param type
	 * @param jsonArray
	 */
	protected  void parseEffectData(DELIVER_TYPE type,JSONObject object,String nodeName){
		
		Map<Long, Long> effectMap = new HashMap<Long, Long>();
		try{
			//曝光数据
			JSONArray jsonArray = object.getJSONArray(nodeName);
			//效果数据
			for (int i = 0; i < jsonArray.size(); i++) {
				JSONObject data = (JSONObject) jsonArray.get(i);
				try{
					if(isValidValues(data.getString("t"))){
						long showTimes = data.getLong("t");
						if (showTimes >= 0) {
							effectMap.put(data.getLong("id"), showTimes);	
						}
					}
				}catch(JSONException e){
					StringBuffer buffer = new StringBuffer();
					buffer.append(type+" Effect Data, JSONException, jsonObject=");
					buffer.append(data.toString()).append(" , ip=").append(taskDTO.getIp());
					logger.error(buffer.toString(),e);
					ErrorStackMessage msg = new ErrorStackMessage(e, buffer.toString(), new MergePolicy(true,true));
					DispatcherConstants.collectErrorStackCollector.produce(msg);
				}
			}
	
			if (!collect.isCollectCompleted()) {
				// put result to map
				collectEffectData.putEffectData(taskDTO.getIp(), effectMap,type);
			}
			
		}catch(Exception e){
			if(nodeName.equals("s") || nodeName.equals("c")){
				StringBuffer buffer = new StringBuffer();
				buffer.append(type+" Effect Data, JSONException, ps=null");
				logger.error(buffer.toString(),e);
				ErrorStackMessage msg = new ErrorStackMessage(e, buffer.toString(), new MergePolicy(true,true));
				DispatcherConstants.collectErrorStackCollector.produce(msg);
			}
		}
	}
	
	/**
	 * 包装运行状态
	 * @return
	 */
	protected CollectRunStatus wrapperRunStatus() {
		CollectRunStatus runStatus = new CollectRunStatus();
		runStatus.setIp(taskDTO.getIp());
		runStatus.setGenerateJsonCost(getGenerateJsonCost());
		runStatus.setThreadRunTime(getEndTime() - taskDTO.getBeginTime());
		runStatus.setRunStatus(isRunStatus());
		runStatus.setReTryRunTimeList(getReTryRunTimeList());
		return runStatus;
	}
	
	/**
	 * 检查数据是否有效
	 * @param content
	 * @return
	 */
	private boolean isValidValues(String content){
		
		if(content==null || content.length()==0 || content.getBytes().length>12){
			return false;
		}
		return true;
	}
	
	public List<Long> getReTryRunTimeList() {
		return reTryRunTimeList;
	}

	public long getEndTime() {
		return endTime;
	}

	public boolean isRunStatus() {
		return runStatus;
	}

	public String getResult() {
		return result;
	}

	public int getGenerateJsonCost() {
		return generateJsonCost;
	}
}

 

主进程控制

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.GzipDecompressingEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.protocol.HttpContext;
import org.slf4j.Logger;

import com.javagc.context.ServerGroupContext;
import com.javagc.context.ServerGroupContext.GROUPS;
import com.javagc.entity.CollectRunStatus;
import com.javagc.entity.CollectEffectData;
import com.javagc.entity.CollectTaskDTO;
import com.javagc.task.EffectCollectTask;
import com.javagc.util.DispatcherConstants;
import com.javagc.util.DispatcherUtil;

/**
 * 收账服务<br>
 * 1、一组服务器收账使用最大时长,@see DispatcherConstants.COLLECTOR_TOTALTIMEOUT
 * @author stevending<br>
 *
 */
public class CollectService implements ICollectService {

	private static final Logger logger = DispatcherUtil.getLog();
	
	/**
	 * 分组信息
	 */
	private GROUPS groupNum;
	/**
	 * 收账结果日志
	 */
	private Map<String,CollectRunStatus> runStatusMap = null;
	/**
	 * 结果数据
	 */
	private CollectEffectData 		effectData 	= null;
	/**
	 * 检测是否完成收账
	 */
	private CountDownLatch 	latch 		= null;
	/**
	 * 收账完成状态 true=完成、false=未完成
	 */
	private AtomicBoolean	collectCompleted = new AtomicBoolean(false);
	
	/**
	 * 构造方法
	 * @param groupNum
	 */
	public EffectCollectService(GROUPS groupNum){
		this.groupNum = groupNum;
	}
	
	
	@Override
	public CollectEffectData doCollect() throws InterruptedException{
		
		long beginTime = System.currentTimeMillis();
		try{
			//exec task
			exeTask();
		} finally{
			collectCompleted.set(true);
			//write run status
			writeRunStatus();
		}
		logger.info(groupNum+" Total runTime:"+(System.currentTimeMillis()-beginTime) + " ms");
		return effectData;
	}
	
	/**
	 * 执行任务
	 * @throws InterruptedException
	 */
	private void exeTask() throws InterruptedException{
		
		long beginTime		= System.currentTimeMillis();
		List<String> ips 	= ServerGroupContext.I.getGroupServerIps(groupNum);
		latch		=	new CountDownLatch(ips.size());
		runStatusMap 	= 	new ConcurrentHashMap<String,CollectRunStatus>();
		effectData 	=	new CollectEffectData();
		
		for(int i=0;i<ips.size();i++){
			CollectTaskDTO staskDTO = new CollectTaskDTO( getHttpClient(),
														getHttpGet(ips.get(i),DispatcherConstants.COLLECTOR_PORT),
														ips.get(i),
														DispatcherConstants.COLLECTOR_TOTALTIMEOUT,
														beginTime);
			CollectTask stask = new CollectTask(staskDTO,effectData,runStatusMap,latch,this,groupNum);
			Thread st = new Thread(stask);
			st.setDaemon(true);
			st.start();
		}
		//等待收账完成
		latch.await(DispatcherConstants.COLLECTOR_TOTALTIMEOUT, TimeUnit.MILLISECONDS);
		
		//TODO 清理未完成的线程
	}
	
	/**
	 * 记录运行状态
	 */
	protected void writeRunStatus(){
		
		StringBuffer logBuffer = new StringBuffer("收账过程日志\n");
		List<String> ips = ServerGroupContext.I.getGroupServerIps(groupNum);
		for(int i=0;i<ips.size();i++){
			String ip = ips.get(i);
			if(runStatusMap.get(ip) == null){
				CollectRunStatus consumerStatus = new CollectRunStatus();
				consumerStatus.setIp(ip);
				consumerStatus.setRunStatus(false);
				consumerStatus.setThreadRunTime(DispatcherConstants.COLLECTOR_TOTALTIMEOUT);
				runStatusMap.put(ip, consumerStatus);
			}
			logBuffer.append(runStatusMap.get(ip).toString()).append("\n");
		}
		
		logger.info(logBuffer.toString());
	}
	
	/**
	 * 获取httpClient
	 * @return
	 */
	protected HttpClient getHttpClient(){
		
		DefaultHttpClient httpclient = new DefaultHttpClient();
		
		httpclient.addRequestInterceptor(new HttpRequestInterceptor() {
            public void process(final HttpRequest request,final HttpContext context) throws HttpException, IOException {
                if (!request.containsHeader("Accept-Encoding")) {
                    request.addHeader("Accept-Encoding", "gzip");
                }
            }
        });

        httpclient.addResponseInterceptor(new HttpResponseInterceptor() {
            public void process(final HttpResponse response,final HttpContext context) throws HttpException, IOException {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    Header ceheader = entity.getContentEncoding();
                    if (ceheader != null) {
                        HeaderElement[] codecs = ceheader.getElements();
                        for (int i = 0; i < codecs.length; i++) {
                            if (codecs[i].getName().equalsIgnoreCase("gzip")) {
                                response.setEntity(new GzipDecompressingEntity(response.getEntity()));
                                return;
                            }
                        }
                    }
                }
            }
        });
        
        httpclient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT,DispatcherConstants.COLLECTOR_CONNTIMEOUT);
        httpclient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT,DispatcherConstants.COLLECTOR_READTIMEOUT);
		
		return httpclient;
	}
	
	protected HttpGet getHttpGet(String ip,int port){
		StringBuffer buffer = new StringBuffer();
		buffer.append("http://").append(ip);
		buffer.append(":").append(port);
		buffer.append(DispatcherConstants.COLLECTOR_URL);
		return new HttpGet(buffer.toString());
	}
	
	@Override
	public boolean isCollectCompleted() {
		return collectCompleted.get();
	}

}

 

 

话务中心运营工作方案
11-08
6. **员工培训与能力提升**：完善的再培训机制确保员工不断提升话务技巧，提高成单率、搭销率和签单率等业绩指标，维持高广告投入产出比。 7. **工作习惯与效率**：培养员工良好的工作习惯，以提高话务中心的管理...
广告引擎策略
蝉之洞
08-20 3318
2. 智能推荐引擎 通过各种训练及机器学习，我们可以在竞价前（离线）对历史的广告请求、广告投放、点击后到站及转化等等大量历史数据，进行训练离线模型。当有广告曝光机会竞价请求，DSP被邀请参与竞价的时候，DSP方的智能推荐引擎根据广告请求的人群标签、浏览器、时间、地域、广告位尺寸等等多维度特征，并结合广告创意的特征，依据离线已事先训练好的，对不同特征效果预测的数据模型，预测该次广告展现可能产生的价...
一个欠揍的广告语
weixin_34280237的博客
09-06 130
前天,老刘买了一瓶七喜,瓶子上有广告语:七喜小子语录*分享篇三五知己,干杯七喜这个广告语太TM欠揍了 转载于:https://www.cnblogs.com/phil/archive/2009/09/06/1561153.html...
公交车智能调度
06-20
雅迅公司的解决方案涵盖了系统设计的各个方面，包括系统的目标、原则、框架结构、业务模块、网络结构以及中心系统的架构。该系统具备多种特色功能，如车载DVR（数字视频录像机）功能，用于记录车辆行驶过程中的视频...
GPS车载实时异地监控调度系统
07-26
2. **电话叫车服务**：通过调度中心的电话系统，可以为乘客提供便捷的叫车服务，减少空驶率，提高整体运营效率。 3. **紧急报警功能**：安装在车辆内部的报警开关一旦被触发，会立即向监控中心发送报警信号及车辆...
海信智能化公交调度系统.pdf
08-29
1. **实时信息交互**：公交车载信息终端与调度中心通过GPRS实时交换数据，提供乘车参考信息，如到站时间、道路状况等，同时在车内向乘客发布。 2. **公交电子信息站牌**：站牌可显示车辆位置、到站时间、交通情况、...
Mybatis
庸不易的博客
11-15 806
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 941
Rest请求处理
java加锁问题详解
qq_74056922的博客
11-14 775
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 521
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
如何合理设计一套springcloud+springboot项目中的各个微服务模块之间的继承关系的最优方案
tigerhhzz的博客
11-14 1142
文章目录一、模块化设计所遵循的原则二、项目架构设计三、各个模块作用说明3.1 core 模块3.2 common 模块3.3 generatorcode模块3.4 business 模块3.5 web 模块3.6 admin 模块3.7 父pom四、采用import引入SpringBoot 在springcloud微服务项目中经常用到多模块化的架构设计，随着业务模块的增多，各个服务模块之间的依赖关系就越来越复杂；本文从项目起初的搭建，给出一套Model优秀设计方案。 一、模块化设计所遵循的原则 单一职责
HashMap源码分析下
L25000的专栏
11-16 624
如果这个cap刚好是2的幂次方呢，即4,8,16,32,64等这样的，这样的数已经满足条件了，再减去1，把数变成3,7,31,63。，即hash值的第5为是1，这样在扩容到32后，取索引得出来的结果就和16的不一样了，索引位置比oldCap大了一个oldCap值；,求余数，n是一个2的幂次方数，减去1，即后面全是1，前面全是0，与上这个hash，只能保证经过运算，结果都会在。，即hash值的第5为是0，这样在扩容到32后，取索引得出来的结果还是和16的一样；cap=1，2的0次方就等于1，返回的是就是4。
BP新增页签增强
BinGeneral的博客
11-15 992
以上就是BP新增页签的介绍，希望对您有所帮助。在总结过程中，该篇文档给予了极大的帮助和借鉴。
【系统架构设计师】真题论文: 论模型驱动架构在系统开发中的应用（包括解题思路和素材）
数据知道的博客
11-14 262
例如，如果目标平台是 Java EE，需要将 PIM 中的业务实体转换为 Java 类，将业务流程转换为符合 Java EE 规范的企业级 JavaBean（EJB）或 Servlet 等组件，同时考虑 Java 平台的数据库访问、事务管理等特性，生成相应的数据库表结构和数据访问代码等。例如，在开发多个不同平台版本的移动应用时，如果采用 MDA，开发人员可以先设计一个统一的 PIM，然后针对不同的移动操作系统（如 Android 和 iOS）生成相应的 PSM 和代码，大大提高了开发效率。
vmWare虚拟环境centos7安装Hadoop 伪分布式实践
最新发布
keep_learn的专栏
11-17 674
背景：近期在研发大数据中台，需要研究Hadoop hive 的各种特性，需要搭建一个Hadoop的虚拟环境，本来想着使用dock ，但突然发现docker 公共仓库的镜像 被XX 了，无奈重新使用vm 搭建虚拟机。大概经历了6个小时完成hadoop 3.3.6 环境的搭建，分享步骤给大家，需要搭建好的虚拟机镜像私信联系，提供百度网盘下载链接。(需要请一杯奶茶)。操作系统版本：centos 7本次实践实践2024年，未来2年内有效。
Struts扫盲
spy47_的博客
11-14 1335
这里的struts是struts1。以本文记录我的那些复习JavaEE的痛苦并快乐的晚上。
基于java的二手图书交易系统
源码好优多
11-16 117
项目编号：springbootA069现代二手图书交易系统综合了共享信息、电子化、智能化等多种技术，对二手图书交易系统的多个流程了实现整合。信息化的二手图书交易系统是由多个分布式子系统组成的，各分布式子系统既可以完全独立运作，又有一定的联系。只有提高二手图书交易系统的各环节、各子系统的信息化水平，才能提高整个二手图书交易系统的运行效率。使用网络化智能分析技术后，可以实时的获取图书信息或用户需求等数据，对海量的数据进行过滤和分析，就能得到有价值的信息。
春意盎然：基于Spring Boot的中药实验管理平台
2401_85339615的博客
11-17 384
同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。可以保证关键数据的安全性。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
互联网广告平台系统架构详解
9. **调度中心**：根据配置文件设置的计算周期，调度中心自动计算下一个投放周期的广告量，并将结果写入投放缓存服务器。ADDispatchEngine和ADDispatchCalculator通过依赖注入模式协作，灵活地适应不同投放策略。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值