一、什么是前置RTA

1.1 传统RTA vs 前置RTA

传统RTA（后置RTA）：媒体方曝光机会 → RTA决策 → 返回出价 → DSP竞价 → 展示广告 ↑ 已有用户画像前置RTA（Pre-RTA）：媒体方曝光机会 → 前置RTA → 用户画像增强 → DSP决策 → 展示广告 ↓ 实时补充/修正用户标签 实时频控检查 实时黑名单过滤

1.2 核心差异

维度	传统RTA	前置RTA
执行时机	DSP竞价前	DSP竞价前，但更早介入
主要目的	出价决策	用户筛选+标签增强
数据来源	离线画像	实时+离线结合
响应时效	≤40ms	≤20ms（更严格）
返回内容	出价+是否竞价	用户标签+是否参与竞价

二、前置RTA的架构设计

2.1 整体架构

@RestControllerpublic class PreRtaController { @Autowired private PreRtaEngine preRtaEngine; @PostMapping("/pre-rta/decision") public PreRtaResponse preRtaDecision(@RequestBody PreRtaRequest request) { // 前置RTA必须在15-20ms内完成 long start = System.nanoTime(); PreRtaResponse response = new PreRtaResponse(); response.setRequestId(request.getRequestId()); try { // 1. 快速身份识别 DeviceInfo deviceInfo = identifyDevice(request); // 2. 实时用户画像增强 EnhancedProfile profile = preRtaEngine.enhanceProfile(deviceInfo); // 3. 黑名单快速过滤 if (preRtaEngine.shouldFilter(profile, request)) { response.setBid(false); response.setFilterReason("pre_filter"); return response; } // 4. 返回增强后的用户标签给DSP response.setBid(true); response.setUserTags(profile.getTags()); response.setRecommendStrategy(profile.getStrategy()); } catch (Exception e) { // 降级：返回默认标签 response.setBid(true); response.setUserTags(getDefaultTags()); } long cost = (System.nanoTime() - start) / 1_000_000; MetricsCollector.record("pre_rta", cost); return response; }}

2.2 核心服务模块

@Servicepublic class PreRtaEngine { @Autowired private DeviceGraphService deviceGraphService; // 设备关系图谱 @Autowired private RealTimeFeatureService realTimeFeatureService; // 实时特征 @Autowired private AntiFraudService antiFraudService; // 反作弊 @Autowired private UserIntentService userIntentService; // 实时意图识别 /** * 用户画像增强 - 前置RTA的核心能力 */ public EnhancedProfile enhanceProfile(DeviceInfo deviceInfo) { EnhancedProfile profile = new EnhancedProfile(); // 1. 多设备ID打通（同一用户的不同设备） List<String> relatedDevices = deviceGraphService.getRelatedDevices( deviceInfo.getDeviceId() ); // 2. 实时特征计算（最近5分钟行为） RealTimeFeatures rtFeatures = realTimeFeatureService.getRTFeatures( deviceInfo.getDeviceId() ); // 3. 反作弊识别 AntiFraudResult fraudResult = antiFraudService.check(deviceInfo); if (fraudResult.isSuspicious()) { profile.setQualityScore(0); profile.setTags(Collections.singletonList("fraud_risk")); return profile; } // 4. 实时意图识别（当前时刻的购买意图） Intent intent = userIntentService.getCurrentIntent( deviceInfo.getDeviceId(), rtFeatures.getLastClickCategory() ); // 5. 构建增强画像 profile.setQualityScore(calculateQualityScore(deviceInfo, rtFeatures)); profile.setIntent(intent); profile.setTags(buildTags(rtFeatures, intent)); profile.setRecommendedCpa(recommendCpa(profile)); // 6. 频控预检查 profile.setFreqStatus(checkFreqStatus(deviceInfo)); return profile; } /** * 快速过滤判断 */ public boolean shouldFilter(EnhancedProfile profile, PreRtaRequest request) { // 1. 质量分过滤 if (profile.getQualityScore() < request.getMinQualityScore()) { return true; } // 2. 反作弊过滤 if (profile.getTags().contains("fraud_risk")) { return true; } // 3. 频控过滤 if (profile.getFreqStatus().isExceeded()) { return true; } // 4. 行业偏好过滤 if (!profile.getIntent().matchIndustry(request.getIndustryId())) { return true; } return false; }}

三、前置RTA的关键技术

3.1 设备关系图谱（Device Graph）

@Servicepublic class DeviceGraphService { @Autowired private RedisTemplate<String, Object> redisTemplate; /** * 设备关系图谱存储 * 将同一用户的不同设备关联起来 */ public List<String> getRelatedDevices(String deviceId) { String graphKey = "rta:device_graph:" + deviceId; // 获取关联设备列表（手机、平板、PC等） Set<String> relatedDevices = redisTemplate.opsForSet() .members(graphKey); // 限制返回数量，避免超时 if (relatedDevices.size() > 10) { relatedDevices = relatedDevices.stream() .limit(10) .collect(Collectors.toSet()); } return new ArrayList<>(relatedDevices); } /** * 更新设备关系（实时） */ public void updateDeviceRelation(String userId, String deviceId, String deviceType) { // 同一用户下的设备关联 String userKey = "rta:user_devices:" + userId; redisTemplate.opsForSet().add(userKey, deviceId); // 双向关联 for (String relatedDevice : redisTemplate.opsForSet().members(userKey)) { if (!relatedDevice.equals(deviceId)) { String deviceKey = "rta:device_graph:" + deviceId; redisTemplate.opsForSet().add(deviceKey, relatedDevice); String relatedKey = "rta:device_graph:" + relatedDevice; redisTemplate.opsForSet().add(relatedKey, deviceId); } } // 设置过期时间（30天） redisTemplate.expire(userKey, 30, TimeUnit.DAYS); redisTemplate.expire("rta:device_graph:" + deviceId, 30, TimeUnit.DAYS); }}

3.2 实时特征计算

@Servicepublic class RealTimeFeatureService { // 使用Redis Sorted Set存储实时行为序列 private static final String BEHAVIOR_KEY = "rta:behavior:{device_id}"; /** * 获取实时特征（最近5分钟） */ public RealTimeFeatures getRTFeatures(String deviceId) { long now = System.currentTimeMillis(); long fiveMinutesAgo = now - 5 * 60 * 1000; String key = BEHAVIOR_KEY.replace("{device_id}", deviceId); // 获取最近5分钟的行为 Set<Object> recentBehaviors = redisTemplate.opsForZSet() .rangeByScore(key, fiveMinutesAgo, now); RealTimeFeatures features = new RealTimeFeatures(); for (Object behavior : recentBehaviors) { BehaviorEvent event = (BehaviorEvent) behavior; // 统计各类行为频次 switch (event.getType()) { case CLICK: features.incrementClickCount(); features.addLastClickCategory(event.getCategory()); break; case SEARCH: features.incrementSearchCount(); features.addSearchKeyword(event.getKeyword()); break; case VIEW: features.incrementViewCount(); break; case DOWNLOAD: features.setHasDownload(true); break; } } // 计算实时活跃度得分 features.setActiveScore(calculateActiveScore(features)); return features; } /** * 实时记录用户行为（通过消息队列异步写入） */ @KafkaListener(topics = "user-behavior") public void recordBehavior(BehaviorEvent event) { String key = BEHAVIOR_KEY.replace("{device_id}", event.getDeviceId()); // 使用ZADD添加行为记录，score为时间戳 redisTemplate.opsForZSet() .add(key, event, event.getTimestamp()); // 只保留最近30分钟的数据 long thirtyMinutesAgo = System.currentTimeMillis() - 30 * 60 * 1000; redisTemplate.opsForZSet() .removeRangeByScore(key, 0, thirtyMinutesAgo); // 设置过期时间1小时 redisTemplate.expire(key, 1, TimeUnit.HOURS); }}

3.3 实时意图识别

@Servicepublic class UserIntentService { @Autowired private MLModelService mlModelService; /** * 实时意图识别（基于当前行为和上下文） */ public Intent getCurrentIntent(String deviceId, String lastClickCategory) { Intent intent = new Intent(); // 1. 获取实时特征向量 RealTimeFeatures rtFeatures = realTimeFeatureService.getRTFeatures(deviceId); // 2. 获取上下文特征（时间、地点等） ContextFeatures context = getContextFeatures(); // 3. 构建特征向量 float[] featureVector = buildFeatureVector(rtFeatures, context); // 4. 调用在线模型预测（本地加载，避免网络延迟） PredictionResult result = mlModelService.predict(featureVector); // 5. 解析意图 intent.setCategory(result.getTopCategory()); intent.setScore(result.getScore()); intent.setBuyIntentLevel(calculateBuyIntentLevel(result, rtFeatures)); // 6. 短期意图修正（基于最近点击） if (lastClickCategory != null) { intent.setShortTermIntent(lastClickCategory); intent.setScore(intent.getScore() * 1.2); // 提升权重 } return intent; } /** * 计算购买意图等级（0-100） */ private int calculateBuyIntentLevel(PredictionResult result, RealTimeFeatures rtFeatures) { int level = 0; // 模型预测分（0-50） level += (int)(result.getScore() * 50); // 搜索行为加成（最多20分） if (rtFeatures.getSearchCount() > 0) { level += Math.min(20, rtFeatures.getSearchCount() * 5); } // 点击行为加成（最多20分） if (rtFeatures.getClickCount() > 0) { level += Math.min(20, rtFeatures.getClickCount() * 4); } // 下载行为加成（10分） if (rtFeatures.isHasDownload()) { level += 10; } return Math.min(100, level); }}

3.4 反作弊前置识别

@Servicepublic class AntiFraudService { // 布隆过滤器存储作弊设备指纹 private BloomFilter<String> fraudBloomFilter; @PostConstruct public void init() { fraudBloomFilter = BloomFilter.create( Funnels.stringFunnel(StandardCharsets.UTF_8), 10_000_000, // 1000万设备 0.001 // 0.1%误判率 ); // 加载已知作弊设备 loadFraudDevices(); } /** * 快速反作弊检测（20ms内完成） */ public AntiFraudResult check(DeviceInfo deviceInfo) { AntiFraudResult result = new AntiFraudResult(); result.setSuspicious(false); // 1. 设备指纹检查 if (fraudBloomFilter.mightContain(deviceInfo.getDeviceFingerprint())) { result.setSuspicious(true); result.setReason("fraud_device_fingerprint"); return result; } // 2. 异常行为检测（基于实时特征） RealTimeFeatures rtFeatures = realTimeFeatureService.getRTFeatures( deviceInfo.getDeviceId() ); // 短时间内大量点击 if (rtFeatures.getClickCount() > 20) { // 5分钟内超过20次点击 result.setSuspicious(true); result.setReason("excessive_clicks"); return result; } // 3. IP风险检测 if (isRiskyIP(deviceInfo.getIp())) { result.setSuspicious(true); result.setRiskScore(0.7); result.setReason("risky_ip"); return result; } // 4. 设备黑名单检查 if (isInDeviceBlacklist(deviceInfo.getDeviceId())) { result.setSuspicious(true); result.setReason("device_blacklist"); return result; } return result; } /** * IP风险检测（使用Redis存储风险IP库） */ private boolean isRiskyIP(String ip) { // 将IP转换为整数 long ipLong = ipToLong(ip); // 检查是否在风险IP段 Set<Object> riskySegments = redisTemplate.opsForSet() .members("rta:risky_ip_segments"); for (Object segment : riskySegments) { IPRange range = (IPRange) segment; if (range.contains(ipLong)) { return true; } } return false; }}

四、前置RTA的Redis缓存优化

4.1 缓存分层设计

@Componentpublic class PreRTACacheManager { // L1: Caffeine本地缓存（热数据） private Cache<String, EnhancedProfile> l1Cache = Caffeine.newBuilder() .maximumSize(200_000) .expireAfterWrite(5, TimeUnit.SECONDS) .recordStats() .build(); // L2: Redis缓存（温数据） @Autowired private RedisTemplate<String, EnhancedProfile> redisTemplate; // L3: 离线数据源（冷数据） @Autowired private OfflineDataSource offlineDataSource; /** * 三级缓存获取用户画像 */ public EnhancedProfile getProfile(String deviceId) { // L1查询（1ms） EnhancedProfile profile = l1Cache.getIfPresent(deviceId); if (profile != null) { return profile; } // L2查询（5ms） String key = "pre_rta:profile:" + deviceId; profile = redisTemplate.opsForValue().get(key); if (profile != null) { l1Cache.put(deviceId, profile); return profile; } // L3查询（异步，避免阻塞） CompletableFuture<EnhancedProfile> future = CompletableFuture.supplyAsync(() -> offlineDataSource.loadProfile(deviceId)); try { profile = future.get(10, TimeUnit.MILLISECONDS); if (profile != null) { // 异步写入L2 asyncWriteToRedis(key, profile); } } catch (TimeoutException e) { // 超时返回默认画像 profile = getDefaultProfile(); } return profile; }}

4.2 预热策略

@Componentpublic class PreRTAPreheater { /** * 定时预热高活跃设备 */ @Scheduled(cron = "0 */5 * * * ?") // 每5分钟执行 public void preheatHotDevices() { // 1. 获取最近5分钟的高活跃设备Top 10000 Set<String> hotDevices = getHotDevicesFromStream(); // 2. 批量加载画像到Redis List<CompletableFuture<Void>> futures = new ArrayList<>(); for (String deviceId : hotDevices) { CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { EnhancedProfile profile = offlineDataSource.loadProfile(deviceId); String key = "pre_rta:profile:" + deviceId; redisTemplate.opsForValue().set(key, profile, 10, TimeUnit.MINUTES); }); futures.add(future); } // 3. 等待预热完成 CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])) .get(30, TimeUnit.SECONDS); } /** * 从实时流获取高活跃设备 */ private Set<String> getHotDevicesFromStream() { // 使用Redis HyperLogLog或Stream统计 Set<String> hotDevices = new HashSet<>(); // 获取最近5分钟的请求设备 long fiveMinutesAgo = System.currentTimeMillis() - 5 * 60 * 1000; Set<Object> devices = redisTemplate.opsForZSet() .rangeByScore("rta:request_stream", fiveMinutesAgo, System.currentTimeMillis()); for (Object device : devices) { hotDevices.add(device.toString()); if (hotDevices.size() >= 10000) { break; } } return hotDevices; }}

五、性能优化与监控

5.1 极致性能优化

@Componentpublic class PreRTAOptimizer { // 使用ThreadLocal缓存避免重复计算 private static final ThreadLocal<Map<String, Object>> CONTEXT_CACHE = ThreadLocal.withInitial(HashMap::new); /** * 批量查询优化 */ public List<EnhancedProfile> batchGetProfiles(List<String> deviceIds) { // 1. 去重 deviceIds = deviceIds.stream().distinct().collect(Collectors.toList()); // 2. 批量查询Redis（使用Pipeline） List<Object> profiles = redisTemplate.executePipelined( (RedisCallback<Object>) connection -> { for (String deviceId : deviceIds) { String key = "pre_rta:profile:" + deviceId; connection.get(key.getBytes()); } return null; } ); // 3. 处理结果 List<EnhancedProfile> result = new ArrayList<>(); for (int i = 0; i < deviceIds.size(); i++) { EnhancedProfile profile = (EnhancedProfile) profiles.get(i); if (profile == null) { // 异步加载缺失的profile asyncLoadProfile(deviceIds.get(i)); profile = getDefaultProfile(); } result.add(profile); } return result; } /** * 使用对象池减少GC */ @Bean public ObjectPool<PreRtaRequest> requestPool() { return new GenericObjectPool<>(new PreRtaRequestFactory()); } /** * 使用堆外内存存储大对象 */ @Bean public DirectByteBufferPool bufferPool() { return new DirectByteBufferPool(1024, 100); }}

5.2 监控指标

@Componentpublic class PreRTAMonitor { private final MeterRegistry meterRegistry; @Autowired public PreRTAMonitor(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; initMetrics(); } private void initMetrics() { // 请求耗时分布 Timer.builder("pre_rta.request.duration") .publishPercentiles(0.5, 0.95, 0.99, 0.999) .register(meterRegistry); // 各阶段耗时 Timer.builder("pre_rta.phase.duration") .tag("phase", "device_graph") .register(meterRegistry); Timer.builder("pre_rta.phase.duration") .tag("phase", "real_time_feature") .register(meterRegistry); Timer.builder("pre_rta.phase.duration") .tag("phase", "intent_recognition") .register(meterRegistry); // 过滤统计 Counter.builder("pre_rta.filter.count") .tag("reason", "quality_score") .register(meterRegistry); Counter.builder("pre_rta.filter.count") .tag("reason", "fraud") .register(meterRegistry); Counter.builder("pre_rta.filter.count") .tag("reason", "frequency") .register(meterRegistry); // 缓存命中率 Gauge.builder("pre_rta.cache.hit_rate", this::calculateCacheHitRate) .register(meterRegistry); } @EventListener public void recordRequest(PreRtaRequestEvent event) { Timer.Sample sample = Timer.start(meterRegistry); try { // 记录请求 meterRegistry.counter("pre_rta.request.total").increment(); } finally { sample.stop(Timer.builder("pre_rta.request.duration") .tag("result", event.getResult()) .register(meterRegistry)); } }}

六、前置RTA的价值

6.1 业务价值

价值点	说明	效果提升
降低DSP成本	提前过滤低质量流量	节省30-50%计算资源
提升ROI	实时意图识别，精准出价	ROI提升15-25%
反作弊前置	实时识别作弊流量	减少20-30%无效消耗
用户体验	频控前置，避免骚扰	用户投诉降低40%
数据时效	秒级画像更新	转化率提升10-15%

6.2 技术优势

更精准：实时行为+离线画像结合更快速：多级缓存+本地计算更智能：在线ML模型实时预测更经济：提前过滤，减少下游负载

6.3 适用场景

电商广告：实时购买意图识别游戏广告：用户质量预判金融广告：风险用户过滤品牌广告：频控+黑名单过滤

前置RTA是RTA技术的重要演进方向，通过在竞价前增加智能决策层，实现了更精细化的流量筛选和更高效的广告投放。

版权声明：本文转载于今日头条，版权归作者所有，如果侵权，请联系本站编辑删除