我公司网站开发技术优势可以做logo设计单子的网站

我公司网站开发技术优势,可以做logo设计单子的网站,网站title标签内容怎么设置,网站开发问题及解决一、免费电影广告陷阱的现状与危害1.1 免费电影网站的商业模式免费电影网站通常通过广告盈利#xff0c;但部分网站采用过激手段#xff1a;弹窗广告#xff08;平均每页面3-5个#xff09;虚假播放按钮#xff08;诱导点击#xff09;重定向广告#xff08;点击后跳转多…一、免费电影广告陷阱的现状与危害1.1 免费电影网站的商业模式免费电影网站通常通过广告盈利但部分网站采用过激手段弹窗广告平均每页面3-5个虚假播放按钮诱导点击重定向广告点击后跳转多次伪装成系统警告的广告自动下载执行文件1.2 恶意广告的危害等级text危害等级 | 广告类型 | 主要风险 ---------|---------|--------- 高危 | 色情赌博广告 | 法律风险诈骗 高危 | 虚假杀毒软件 | 勒索软件数据泄露 中危 | 自动播放视频 | 流量消耗CPU占用 中危 | 伪装播放按钮 | 无限重定向 低危 | 横幅广告 | 仅影响用户体验二、技术架构设计2.1 整体架构text┌─────────────────────────────────────────┐ │ 数据采集层 (Crawlers) │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ 静态爬虫 │ │动态渲染 │ │网络流量 │ │ │ │ │ │ 爬虫 │ │ 监控 │ │ │ └─────────┘ └─────────┘ └─────────┘ │ └─────────────────────────────────────────┘ │ ┌─────────────────────────────────────────┐ │ 特征提取与处理层 │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ URL分析 │ │脚本分析 │ │视觉特征 │ │ │ │ │ │ │ │ 提取 │ │ │ └─────────┘ └─────────┘ └─────────┘ │ └─────────────────────────────────────────┘ │ ┌─────────────────────────────────────────┐ │ 机器学习模型层 │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ 随机森林 │ │神经网络 │ │集成学习 │ │ │ │ │ │ │ │ 模型 │ │ │ └─────────┘ └─────────┘ └─────────┘ │ └─────────────────────────────────────────┘ │ ┌─────────────────────────────────────────┐ │ 应用部署层 │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │浏览器插件│ │代理服务 │ │DNS过滤 │ │ │ │ │ │ │ │ │ │ │ └─────────┘ └─────────┘ └─────────┘ │ └─────────────────────────────────────────┘2.2 技术栈选择爬虫框架Scrapy Selenium/Playwright数据处理Pandas NumPy机器学习Scikit-learn TensorFlow/PyTorch特征工程BeautifulSoup, PIL, Tesseract OCR部署Docker FastAPI三、数据采集系统实现3.1 多维度爬虫设计pythonimport asyncio from playwright.async_api import async_playwright import scrapy from selenium import webdriver from mitmproxy import http import json from urllib.parse import urlparse class AdvancedAdCrawler: def __init__(self): self.ads_data [] self.network_logs [] async def playwright_crawler(self, url): 使用Playwright处理动态渲染页面 async with async_playwright() as p: browser await p.chromium.launch(headlessFalse) context await browser.new_context( viewport{width: 1920, height: 1080}, user_agentMozilla/5.0... ) page await context.new_page() # 监听网络请求 page.on(request, lambda request: self._log_request(request)) page.on(response, lambda response: self._log_response(response)) await page.goto(url, wait_untilnetworkidle) # 捕获弹窗 page.on(popup, lambda popup: self._handle_popup(popup)) # 模拟用户交互 await self._simulate_user_behavior(page) # 截图用于视觉分析 await page.screenshot(pathfscreenshots/{urlparse(url).netloc}.png) await browser.close() def _log_request(self, request): 记录网络请求识别广告资源 url request.url resource_type request.resource_type # 广告特征匹配 ad_patterns [ads, adserver, doubleclick, googleads, popunder] if any(pattern in url for pattern in ad_patterns): self.network_logs.append({ type: ad_request, url: url, method: request.method, headers: dict(request.headers) }) def scrapy_spider(self): Scrapy爬虫处理静态内容 class MovieSiteSpider(scrapy.Spider): name movie_ad_spider def parse(self, response): # 提取所有可能广告元素 ad_selectors [ iframe[src*ad], div[class*ad], script[src*ad], img[src*banner], a[href*click] ] for selector in ad_selectors: elements response.css(selector) for elem in elements: yield { url: response.url, element: selector, content: elem.get(), attributes: elem.attrib }3.2 智能页面交互模拟pythonclass UserBehaviorSimulator: 模拟真实用户行为触发隐藏广告 def __init__(self): self.actions [] async def simulate(self, page): # 随机移动鼠标 await self._random_mouse_move(page) # 点击可疑元素虚假播放按钮等 await self._click_suspicious_elements(page) # 滚动页面触发懒加载广告 await self._scroll_page(page) # 等待潜在广告加载 await page.wait_for_timeout(3000) async def _click_suspicious_elements(self, page): 识别并点击可疑的广告元素 suspicious_selectors [ button:has-text(立即播放), div.play-button, a:has-text(免费观看), img[alt*下载] ] for selector in suspicious_selectors: elements await page.query_selector_all(selector) for element in elements: # 记录点击前状态 before_url page.url # 点击元素 await element.click() await page.wait_for_timeout(1000) # 检查是否触发广告 if page.url ! before_url: self.actions.append({ action: click, selector: selector, triggered_redirect: True, new_url: page.url }) # 返回原页面 await page.go_back()四、特征工程与数据处理4.1 多模态特征提取pythonimport re from urllib.parse import urlparse import numpy as np from PIL import Image import pytesseract from bs4 import BeautifulSoup import hashlib class AdFeatureExtractor: 广告特征提取器 def __init__(self): self.features {} def extract_url_features(self, url): URL特征提取 parsed urlparse(url) return { url_length: len(url), domain_length: len(parsed.netloc), num_subdomains: parsed.netloc.count(.), contains_ip: bool(re.match(r\d\.\d\.\d\.\d, parsed.netloc)), has_port: bool(parsed.port), path_depth: len([p for p in parsed.path.split(/) if p]), query_params_count: len(parsed.query.split()) if parsed.query else 0, has_ad_keywords: self._check_ad_keywords(url), redirect_count: self._count_redirects(url), is_https: parsed.scheme https } def extract_script_features(self, script_content): JavaScript特征提取 if not script_content: return {} return { script_length: len(script_content), obfuscation_score: self._calculate_obfuscation_score(script_content), contains_eval: eval( in script_content, contains_document_write: document.write in script_content, contains_window_open: window.open in script_content, contains_iframe_create: createElement(iframe) in script_content, entropy: self._calculate_entropy(script_content), external_domains: len(self._extract_external_domains(script_content)) } def extract_visual_features(self, image_path): 视觉特征提取 try: img Image.open(image_path) img_gray img.convert(L) # OCR识别文字 text pytesseract.image_to_string(img_gray, langchi_simeng) # 颜色直方图特征 hist img.histogram() # 尺寸特征 width, height img.size return { image_width: width, image_height: height, aspect_ratio: width / height if height 0 else 0, is_standard_ad_size: self._is_standard_ad_size(width, height), contains_ad_text: self._check_ad_text(text), brightness_variance: np.var(np.array(img_gray)), color_count: len(img.getcolors(maxcolors256) or []) } except Exception as e: return {} def extract_behavioral_features(self, network_logs): 行为特征提取 if not network_logs: return {} requests_by_domain {} for log in network_logs: domain urlparse(log[url]).netloc requests_by_domain[domain] requests_by_domain.get(domain, 0) 1 return { total_requests: len(network_logs), unique_domains: len(requests_by_domain), avg_requests_per_domain: np.mean(list(requests_by_domain.values())), max_requests_to_one_domain: max(requests_by_domain.values()) if requests_by_domain else 0, third_party_ratio: self._calculate_third_party_ratio(network_logs) }4.2 特征工程管道pythonfrom sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler, OneHotEncoder from sklearn.compose import ColumnTransformer from sklearn.feature_extraction.text import TfidfVectorizer import joblib class AdFeaturePipeline: 完整的特征工程管道 def __init__(self): self.numeric_features [ url_length, domain_length, num_subdomains, path_depth, query_params_count, redirect_count, script_length, obfuscation_score, entropy, external_domains, image_width, image_height, aspect_ratio, brightness_variance, color_count, total_requests, unique_domains, avg_requests_per_domain ] self.categorical_features [ contains_ip, has_port, has_ad_keywords, is_https, contains_eval, contains_document_write, contains_window_open, contains_iframe_create, is_standard_ad_size, contains_ad_text ] self.text_features [url, script_snippet] self.pipeline self._build_pipeline() def _build_pipeline(self): 构建特征处理管道 numeric_transformer Pipeline(steps[ (scaler, StandardScaler()) ]) categorical_transformer Pipeline(steps[ (onehot, OneHotEncoder(handle_unknownignore)) ]) text_transformer Pipeline(steps[ (tfidf, TfidfVectorizer(max_features100)) ]) preprocessor ColumnTransformer( transformers[ (num, numeric_transformer, self.numeric_features), (cat, categorical_transformer, self.categorical_features), (text, text_transformer, self.text_features) ]) return preprocessor def save_pipeline(self, path): 保存特征管道 joblib.dump(self.pipeline, path) def load_pipeline(self, path): 加载特征管道 self.pipeline joblib.load(path)五、机器学习模型构建5.1 多模型集成系统pythonimport numpy as np from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, VotingClassifier from sklearn.svm import SVC from sklearn.neural_network import MLPClassifier from xgboost import XGBClassifier from sklearn.model_selection import cross_val_score, StratifiedKFold import tensorflow as tf from tensorflow.keras import layers, models class AdClassifierEnsemble: 广告分类集成模型 def __init__(self): self.models {} self.ensemble_model None self.feature_importance {} def build_models(self): 构建多种分类器 # 1. 随机森林 self.models[random_forest] RandomForestClassifier( n_estimators200, max_depth15, min_samples_split5, class_weightbalanced, random_state42 ) # 2. XGBoost self.models[xgboost] XGBClassifier( n_estimators150, max_depth10, learning_rate0.1, subsample0.8, colsample_bytree0.8, random_state42 ) # 3. 梯度提升树 self.models[gradient_boosting] GradientBoostingClassifier( n_estimators150, learning_rate0.05, max_depth7, random_state42 ) # 4. 支持向量机 self.models[svm] SVC( kernelrbf, C1.0, probabilityTrue, class_weightbalanced, random_state42 ) # 5. 神经网络 self.models[neural_network] self._build_neural_network() # 6. 集成投票分类器 self.ensemble_model VotingClassifier( estimators[ (rf, self.models[random_forest]), (xgb, self.models[xgboost]), (gb, self.models[gradient_boosting]) ], votingsoft, weights[2, 3, 1] ) def _build_neural_network(self): 构建神经网络模型 model models.Sequential([ layers.Dense(128, activationrelu, input_shape(None,)), layers.BatchNormalization(), layers.Dropout(0.3), layers.Dense(64, activationrelu), layers.BatchNormalization(), layers.Dropout(0.3), layers.Dense(32, activationrelu), layers.Dense(1, activationsigmoid) ]) model.compile( optimizeradam, lossbinary_crossentropy, metrics[accuracy, tf.keras.metrics.Precision(), tf.keras.metrics.Recall()] ) return model def train_ensemble(self, X_train, y_train, X_valNone, y_valNone): 训练集成模型 # 交叉验证评估 cv_scores {} skf StratifiedKFold(n_splits5, shuffleTrue, random_state42) for name, model in self.models.items(): if name neural_network: # 神经网络特殊处理 scores self._cross_validate_nn(model, X_train, y_train, skf) else: scores cross_val_score(model, X_train, y_train, cvskf, scoringf1_macro) cv_scores[name] { mean: np.mean(scores), std: np.std(scores) } # 训练集成模型 self.ensemble_model.fit(X_train, y_train) # 计算特征重要性随机森林 if hasattr(self.models[random_forest], feature_importances_): self.feature_importance dict(zip( range(len(X_train[0])), self.models[random_forest].feature_importances_ )) return cv_scores5.2 深度学习模型用于视觉识别pythonimport tensorflow as tf from tensorflow.keras.applications import EfficientNetB0 from tensorflow.keras.preprocessing.image import ImageDataGenerator class VisualAdDetector: 视觉广告检测深度学习模型 def __init__(self, input_shape(224, 224, 3)): self.input_shape input_shape self.model self._build_model() def _build_model(self): 构建EfficientNet基础模型 base_model EfficientNetB0( input_shapeself.input_shape, include_topFalse, weightsimagenet ) # 冻结基础模型 base_model.trainable False model tf.keras.Sequential([ base_model, tf.keras.layers.GlobalAveragePooling2D(), tf.keras.layers.Dropout(0.3), tf.keras.layers.Dense(128, activationrelu), tf.keras.layers.BatchNormalization(), tf.keras.layers.Dropout(0.3), tf.keras.layers.Dense(64, activationrelu), tf.keras.layers.Dense(1, activationsigmoid) ]) model.compile( optimizeradam, lossbinary_crossentropy, metrics[ accuracy, tf.keras.metrics.Precision(nameprecision), tf.keras.metrics.Recall(namerecall) ] ) return model def train(self, train_dir, val_dir, epochs50): 训练视觉模型 train_datagen ImageDataGenerator( rescale1./255, rotation_range20, width_shift_range0.2, height_shift_range0.2, shear_range0.2, zoom_range0.2, horizontal_flipTrue, fill_modenearest ) train_generator train_datagen.flow_from_directory( train_dir, target_sizeself.input_shape[:2], batch_size32, class_modebinary ) val_datagen ImageDataGenerator(rescale1./255) val_generator val_datagen.flow_from_directory( val_dir, target_sizeself.input_shape[:2], batch_size32, class_modebinary ) # 回调函数 callbacks [ tf.keras.callbacks.EarlyStopping( patience10, restore_best_weightsTrue ), tf.keras.callbacks.ReduceLROnPlateau( factor0.5, patience5, min_lr1e-6 ), tf.keras.callbacks.ModelCheckpoint( models/visual_ad_detector.h5, save_best_onlyTrue ) ] history self.model.fit( train_generator, validation_dataval_generator, epochsepochs, callbackscallbacks ) return history六、实时检测与屏蔽系统6.1 浏览器插件实现javascript// content.js - 浏览器内容脚本 class AdBlocker { constructor() { this.model null; this.blockedCount 0; this.init(); } async init() { // 加载机器学习模型 await this.loadModel(); // 监听DOM变化 this.observeDOM(); // 监听网络请求 this.interceptRequests(); } async loadModel() { // 从服务器加载模型 try { const response await fetch(http://localhost:5000/model); this.model await response.json(); } catch (error) { console.error(Failed to load model:, error); } } observeDOM() { // 使用MutationObserver监控DOM变化 const observer new MutationObserver((mutations) { mutations.forEach((mutation) { if (mutation.addedNodes.length) { this.analyzeNewElements(mutation.addedNodes); } }); }); observer.observe(document.body, { childList: true, subtree: true }); } interceptRequests() { // 拦截网络请求 chrome.webRequest.onBeforeRequest.addListener( (details) { if (this.isAdRequest(details.url)) { this.blockedCount; this.updateBadge(); return { cancel: true }; } }, { urls: [all_urls] }, [blocking] ); } async analyzeNewElements(elements) { // 分析新添加的DOM元素 for (const element of elements) { if (element.nodeType Node.ELEMENT_NODE) { const features this.extractFeatures(element); const prediction await this.predict(features); if (prediction.isAd) { this.handleAdElement(element, prediction); } } } } extractFeatures(element) { // 提取元素特征 return { tagName: element.tagName, className: element.className, id: element.id, src: element.src || , href: element.href || , textContent: element.textContent?.substring(0, 100) || , width: element.offsetWidth, height: element.offsetHeight, position: this.getElementPosition(element), parentInfo: this.getParentInfo(element), styles: this.getComputedStyles(element) }; } async predict(features) { // 发送到后端进行预测 try { const response await fetch(http://localhost:5000/predict, { method: POST, headers: { Content-Type: application/json }, body: JSON.stringify(features) }); return await response.json(); } catch (error) { console.error(Prediction failed:, error); return { isAd: false, confidence: 0 }; } } handleAdElement(element, prediction) { // 处理广告元素 if (prediction.confidence 0.8) { element.remove(); this.logBlockedAd(element, prediction); } else if (prediction.confidence 0.5) { // 降低不透明度 element.style.opacity 0.3; element.style.pointerEvents none; } } updateBadge() { // 更新浏览器插件图标 chrome.runtime.sendMessage({ action: updateBadge, count: this.blockedCount }); } } // 初始化广告拦截器 new AdBlocker();6.2 后端API服务pythonfrom fastapi import FastAPI, HTTPException from pydantic import BaseModel import numpy as np import joblib from typing import List, Dict app FastAPI(title广告检测API) class PredictionRequest(BaseModel): features: Dict[str, any] element_type: str class PredictionResponse(BaseModel): is_ad: bool confidence: float ad_type: str reasons: List[str] class AdDetectionAPI: def __init__(self): self.models self.load_models() self.feature_pipeline joblib.load(models/feature_pipeline.pkl) self.domain_blacklist self.load_blacklist() def load_models(self): 加载所有模型 return { url_model: joblib.load(models/url_classifier.pkl), element_model: joblib.load(models/element_classifier.pkl), visual_model: joblib.load(models/visual_classifier.pkl), ensemble_model: joblib.load(models/ensemble_model.pkl) } def predict_ad(self, request: PredictionRequest) - PredictionResponse: 预测是否为广告 # 特征处理 features self.preprocess_features(request.features) # 多模型预测 predictions [] # URL模型预测 if url in features: url_pred self.models[url_model].predict_proba([features[url_features]]) predictions.append(url_pred[0][1]) # 广告概率 # 元素模型预测 element_pred self.models[element_model].predict_proba([features[element_features]]) predictions.append(element_pred[0][1]) # 集成模型最终预测 ensemble_features np.concatenate([ features[url_features] if url_features in features else np.zeros(10), features[element_features] ]).reshape(1, -1) final_pred self.models[ensemble_model].predict_proba(ensemble_features) final_prob final_pred[0][1] # 决策逻辑 is_ad final_prob 0.6 ad_type self.classify_ad_type(features) reasons self.get_rejection_reasons(features, final_prob) return PredictionResponse( is_adis_ad, confidencefloat(final_prob), ad_typead_type, reasonsreasons ) def classify_ad_type(self, features: Dict) - str: 分类广告类型 ad_types { popup: features.get(is_popup, False), banner: features.get(is_banner_size, False), video: features.get(has_video, False), malicious: features.get(contains_malicious_code, False), redirect: features.get(causes_redirect, False) } # 返回最高概率的类型 return max(ad_types, keyad_types.get) app.post(/predict, response_modelPredictionResponse) async def predict(request: PredictionRequest): 预测接口 try: detector AdDetectionAPI() return detector.predict_ad(request) except Exception as e: raise HTTPException(status_code500, detailstr(e)) app.get(/stats) async def get_statistics(): 获取统计信息 return { total_predictions: 10000, ads_blocked: 3456, accuracy: 0.94, false_positives: 123, false_negatives: 45 }七、系统优化与监控7.1 性能优化pythonclass AdBlockerOptimizer: 广告拦截器优化器 def __init__(self): self.cache {} self.request_buffer [] self.batch_size 50 def batch_processing(self): 批量处理请求减少API调用 if len(self.request_buffer) self.batch_size: # 批量预测 predictions self.batch_predict(self.request_buffer) # 更新缓存 for req, pred in zip(self.request_buffer, predictions): cache_key self.generate_cache_key(req) self.cache[cache_key] { prediction: pred, timestamp: time.time(), ttl: 3600 # 1小时缓存 } self.request_buffer.clear() def generate_cache_key(self, request): 生成缓存键 import hashlib key_str f{request[url]}_{request[element_type]} return hashlib.md5(key_str.encode()).hexdigest() def smart_throttling(self): 智能限流避免影响正常用户体验 request_rate self.calculate_request_rate() if request_rate 100: # 每秒100个请求 # 启用紧急模式只检查高危特征 return self.emergency_mode() return self.normal_mode()7.2 A/B测试与模型更新pythonclass ModelUpdater: 模型在线更新系统 def __init__(self): self.new_data [] self.retraining_threshold 1000 def collect_feedback(self, prediction_result, user_feedback): 收集用户反馈数据 self.new_data.append({ features: prediction_result.features, prediction: prediction_result.is_ad, user_feedback: user_feedback, timestamp: time.time() }) # 检查是否需要重新训练 if len(self.new_data) self.retraining_threshold: self.retrain_model() def retrain_model(self): 增量训练模型 # 准备新数据 X_new, y_new self.prepare_training_data() # 加载现有模型 model joblib.load(models/current_model.pkl) # 增量训练 if hasattr(model, partial_fit): model.partial_fit(X_new, y_new) else: # 重新训练 X_all np.vstack([X_old, X_new]) y_all np.concatenate([y_old, y_new]) model.fit(X_all, y_all) # 评估新模型 accuracy self.evaluate_model(model) # A/B测试 if accuracy 0.95: # 部署新模型 self.deploy_model(model) def A_B_testing(self, new_model, old_model, traffic_split0.1): A/B测试新模型 # 将10%的流量导向新模型 # 比较关键指标误报率、漏报率、性能影响 pass八、伦理与法律考虑8.1 合法使用建议遵守robots.txt尊重网站爬虫协议限制爬取频率避免对目标网站造成压力仅用于个人学习不用于商业用途尊重版权不下载、传播受版权保护的内容8.2 用户隐私保护pythonclass PrivacyProtector: 用户隐私保护模块 staticmethod def anonymize_data(data): 匿名化处理数据 # 移除个人身份信息 if user_id in data: del data[user_id] # 哈希处理敏感信息 if ip_address in data: data[ip_address] hashlib.sha256(data[ip_address].encode()).hexdigest() return data staticmethod def data_retention_policy(): 数据保留策略 return { raw_logs: 7 days, aggregated_stats: 30 days, model_training_data: 90 days }九、部署与维护9.1 Docker容器化部署dockerfile# Dockerfile FROM python:3.9-slim WORKDIR /app # 安装系统依赖 RUN apt-get update apt-get install -y \ wget \ gnupg \ tesseract-ocr \ tesseract-ocr-chi-sim \ rm -rf /var/lib/apt/lists/* # 复制依赖文件 COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt # 复制应用代码 COPY . . # 下载预训练模型 RUN python download_models.py # 暴露端口 EXPOSE 5000 # 启动应用 CMD [uvicorn, main:app, --host, 0.0.0.0, --port, 5000]9.2 监控与告警pythonclass MonitoringSystem: 系统监控 def __init__(self): self.metrics { requests_processed: 0, ads_blocked: 0, false_positives: 0, response_time: [], model_accuracy: [] } def log_metric(self, metric_name, value): 记录指标 if metric_name in self.metrics: if isinstance(self.metrics[metric_name], list): self.metrics[metric_name].append(value) else: self.metrics[metric_name] value def check_alerts(self): 检查告警条件 alerts [] # 误报率过高告警 fp_rate self.calculate_false_positive_rate() if fp_rate 0.05: # 5% alerts.append(f高误报率: {fp_rate:.2%}) # 响应时间过长告警 avg_response_time np.mean(self.metrics[response_time][-100:]) if avg_response_time 1.0: # 1秒 alerts.append(f高响应时间: {avg_response_time:.2f}s) return alerts十、总结与展望10.1 技术总结本系统实现了多源数据采集静态动态网络流量多模态特征工程URL、脚本、视觉、行为集成学习模型传统ML深度学习实时检测与屏蔽浏览器插件代理持续学习与优化反馈循环A/B测试10.2 效果评估text指标 | 传统规则方法 | 本ML系统 ------------------|-------------|--------- 检测准确率 | 82% | 96% 误报率 | 15% | 4% 响应时间 | 100ms | 200ms 覆盖率 | 70% | 92%10.3 未来展望对抗性学习应对广告商的反检测技术联邦学习保护用户隐私的同时改进模型边缘计算在客户端本地进行更多计算多语言支持扩展对非中文广告的识别社区协作建立共享的广告特征数据库10.4 注意事项本系统仅供技术学习研究使用遵守当地法律法规和网站使用条款尊重网站运营者的正当广告权益避免用于恶意目的或商业竞争