06_apollo_third_party子模块整体软件架构深入分析文档
1. 概述
Apollo third_party子模块是Apollo自动驾驶平台的第三方依赖管理系统，集成了上百种开源和商业库，提供基础功能支持。采用集中式管理架构，实现依赖版本统一控制、编译配置标准化和跨平台兼容性，确保各模块间依赖一致性，简化平台构建和维护流程，为Apollo核心功能提供稳定可靠的基础支撑。
2. 软件架构图
Apollo third_party子模块采用分层架构设计，将第三方依赖按照功能和使用场景划分为多个层次，各层次之间通过清晰的接口进行交互。整个架构遵循模块化、可扩展、可维护的设计原则，确保了第三方依赖的稳定性和可靠性。
graph TB
subgraph "third_party子模块"
subgraph "基础库层"
B1[C++标准库扩展]:::key
B2[数学计算库]:::key
B3[系统工具库]:::key
B4[字符串处理库]:::key
B5[容器库]:::key
end
subgraph "核心功能层"
C1[序列化库]:::key
C2[网络通信库]:::key
C3[日志库]:::key
C4[配置管理库]:::key
C5[测试框架]:::key
end
subgraph "算法库层"
A1[计算机视觉库]:::key
A2[深度学习库]:::key
A3[路径规划库]:::key
A4[传感器处理库]:::key
A5[定位算法库]:::key
end
subgraph "硬件接口层"
H1[GPU加速库]:::key
H2[传感器驱动库]:::key
H3[CAN总线库]:::key
H4[相机库]:::key
H5[雷达库]:::key
end
subgraph "工具库层"
T1[构建工具]:::key
T2[代码质量工具]:::key
T3[调试工具]:::key
T4[性能分析工具]:::key
T5[文档生成工具]:::key
end
end
subgraph "外部依赖"
E1[操作系统API]:::key
E2[硬件驱动]:::key
E3[开源社区库]:::key
end
subgraph "集成系统"
I1[Bazel构建系统]:::key
I2[CyberRT框架]:::key
I3[模块系统]:::key
end
B1 --> C1
B2 --> C2
B3 --> C3
B4 --> C4
B5 --> C5
C1 --> A1
C2 --> A2
C3 --> A3
C4 --> A4
C5 --> A5
A1 --> H1
A2 --> H2
A3 --> H3
A4 --> H4
A5 --> H5
T1 --> B1
T2 --> B2
T3 --> B3
T4 --> B4
T5 --> B5
E1 --> B1
E2 --> H1
E3 --> B1
I1 --> B1
I2 --> C1
I3 --> A1
classDef key fill:#e1f5fe
3. 调用流程图
Apollo third_party子模块的调用流程涵盖了从依赖加载到功能使用的完整生命周期，包括依赖配置、依赖编译、依赖链接和功能调用等多个阶段。整个流程设计清晰，步骤明确，便于开发者理解和使用。
3.1. 依赖配置流程
sequenceDiagram
participant User as 开发者
participant Bazel as Bazel构建系统
participant ThirdParty as third_party子模块
participant Dep as 依赖库
User->>Bazel: 执行构建命令
Bazel->>ThirdParty: 加载第三方依赖配置
ThirdParty->>ThirdParty: 解析依赖配置
ThirdParty->>ThirdParty: 检查依赖版本
ThirdParty->>ThirdParty: 验证依赖兼容性
ThirdParty->>Dep: 加载依赖库
Dep-->>ThirdParty: 依赖库加载完成
ThirdParty-->>Bazel: 依赖配置加载完成
Bazel-->>User: 构建配置完成
3.2. 依赖编译流程
sequenceDiagram
participant User as 开发者
participant Bazel as Bazel构建系统
participant ThirdParty as third_party子模块
participant Dep as 依赖库
User->>Bazel: 执行编译命令
Bazel->>ThirdParty: 启动依赖编译
ThirdParty->>ThirdParty: 准备编译环境
ThirdParty->>ThirdParty: 生成编译配置
ThirdParty->>Dep: 编译依赖库
Dep->>Dep: 执行编译命令
Dep->>Dep: 生成目标文件
Dep-->>ThirdParty: 依赖库编译完成
ThirdParty-->>Bazel: 依赖编译完成
Bazel-->>User: 编译完成
3.3. 依赖链接流程
sequenceDiagram
participant User as 开发者
participant Bazel as Bazel构建系统
participant ThirdParty as third_party子模块
participant Dep as 依赖库
participant Target as 目标程序
User->>Bazel: 执行链接命令
Bazel->>ThirdParty: 启动依赖链接
ThirdParty->>ThirdParty: 准备链接环境
ThirdParty->>ThirdParty: 生成链接配置
ThirdParty->>Dep: 加载依赖库
Dep-->>ThirdParty: 依赖库加载完成
ThirdParty->>Target: 链接依赖库
Target-->>ThirdParty: 依赖链接完成
ThirdParty-->>Bazel: 依赖链接完成
Bazel-->>User: 链接完成
3.4. 功能调用流程
sequenceDiagram
participant User as 开发者
participant Module as Apollo模块
participant ThirdParty as third_party子模块
participant Dep as 依赖库
User->>Module: 调用Apollo功能
Module->>ThirdParty: 调用第三方依赖
ThirdParty->>Dep: 加载依赖库
Dep-->>ThirdParty: 依赖库加载完成
ThirdParty->>Dep: 调用依赖库功能
Dep->>Dep: 执行功能
Dep-->>ThirdParty: 功能执行完成
ThirdParty-->>Module: 结果返回
Module-->>User: 功能调用完成
3.5. 依赖更新流程
sequenceDiagram
participant User as 开发者
participant ThirdParty as third_party子模块
participant Repo as 依赖仓库
User->>ThirdParty: 执行依赖更新
ThirdParty->>ThirdParty: 检查依赖更新
ThirdParty->>Repo: 查询最新版本
Repo-->>ThirdParty: 最新版本返回
ThirdParty->>ThirdParty: 验证版本兼容性
ThirdParty->>Repo: 下载新版本
Repo-->>ThirdParty: 新版本下载完成
ThirdParty->>ThirdParty: 更新依赖配置
ThirdParty->>ThirdParty: 重新编译依赖
ThirdParty-->>User: 依赖更新完成
4. 详细UML类图
Apollo third_party子模块的UML类图展示了系统的核心组件、它们之间的关系以及各自的职责。类图设计遵循面向对象的设计原则，确保了系统的模块化、可扩展性和可维护性。
4.1. 核心模块类图
核心模块类图展示了third_party子模块的主要组件及其之间的关系，包括依赖管理器、版本控制器、编译配置器等核心类。这些类构成了third_party子模块的骨架，负责系统的整体协调和管理。
classDiagram
class ThirdPartyManager {
+initialize()
+loadDependencies()
+compileDependencies()
+linkDependencies()
+updateDependencies()
+getDependency(string): Dependency
+getAllDependencies(): list
-dependencyManager: DependencyManager
-versionController: VersionController
-buildConfigurer: BuildConfigurer
-logger: Logger
}
class DependencyManager {
+registerDependency(Dependency)
+unregisterDependency(string)
+getDependency(string): Dependency
+getDependenciesByType(string): list
+getDependenciesByVersion(string): list
-dependencies: map
-dependencyGraph: DependencyGraph
}
class VersionController {
+checkVersion(string): bool
+updateVersion(string, string): bool
+getLatestVersion(string): string
+getCompatibleVersions(string, string): list
-versionDatabase: VersionDatabase
-compatibilityRules: CompatibilityRules
}
class BuildConfigurer {
+generateBuildConfig(Dependency): BuildConfig
+configureBuildEnvironment()
+validateBuildConfig(BuildConfig): bool
-buildTemplates: map
-compilerOptions: CompilerOptions
}
class Dependency {
+getName(): string
+getVersion(): string
+getType(): string
+getDependencies(): list
+getBuildConfig(): BuildConfig
+setVersion(string): void
+addDependency(Dependency): void
-name: string
-version: string
-type: string
-dependencies: list
-buildConfig: BuildConfig
}
class DependencyGraph {
+addNode(Dependency)
+addEdge(Dependency, Dependency)
+getTopologicalOrder(): list
+hasCycle(): bool
+getDependenciesOf(Dependency): list
-nodes: map
-edges: map>
}
class VersionDatabase {
+getVersionInfo(string): VersionInfo
+updateVersionInfo(VersionInfo)
+getAllVersions(string): list
-versions: map>
}
class CompatibilityRules {
+isCompatible(string, string, string): bool
+addRule(CompatibilityRule)
+removeRule(string)
-rules: list
}
class BuildConfig {
+getCompilerFlags(): list
+getLinkerFlags(): list
+getIncludePaths(): list
+getLibraryPaths(): list
+setCompilerFlag(string): void
-compilerFlags: list
-linkerFlags: list
-includePaths: list
-libraryPaths: list
}
ThirdPartyManager --> DependencyManager
ThirdPartyManager --> VersionController
ThirdPartyManager --> BuildConfigurer
ThirdPartyManager --> Logger
DependencyManager --> Dependency
DependencyManager --> DependencyGraph
VersionController --> VersionDatabase
VersionController --> CompatibilityRules
BuildConfigurer --> BuildConfig
Dependency --> BuildConfig
DependencyGraph --> Dependency
VersionDatabase --> VersionInfo
CompatibilityRules --> CompatibilityRule
4.2. 依赖管理类图
依赖管理类图展示了third_party子模块的依赖管理系统，包括依赖加载器、依赖解析器、依赖验证器等核心类。这些类负责依赖的加载、解析、验证和管理，确保了依赖的一致性和可靠性。
classDiagram
class DependencyLoader {
+loadDependency(string): Dependency
+loadDependencies(list): list
+setLoadStrategy(LoadStrategy): void
-loadStrategy: LoadStrategy
-dependencyCache: DependencyCache
}
class DependencyResolver {
+resolveDependencies(Dependency): list
+resolveAllDependencies(list): list
+setResolveStrategy(ResolveStrategy): void
-resolveStrategy: ResolveStrategy
-dependencyGraph: DependencyGraph
}
class DependencyValidator {
+validateDependency(Dependency): bool
+validateDependencies(list): bool
+setValidationRules(list): void
-validationRules: list
-compatibilityChecker: CompatibilityChecker
}
class LoadStrategy {
<>
+load(string): Dependency
}
class LocalLoadStrategy {
+load(string): Dependency
-localPath: string
}
class RemoteLoadStrategy {
+load(string): Dependency
-remoteUrl: string
-downloadManager: DownloadManager
}
class ResolveStrategy {
<>
+resolve(Dependency): list
}
class DepthFirstResolveStrategy {
+resolve(Dependency): list
}
class BreadthFirstResolveStrategy {
+resolve(Dependency): list
}
class ValidationRule {
<>
+validate(Dependency): bool
}
class VersionValidationRule {
+validate(Dependency): bool
-versionPattern: string
}
class CompatibilityValidationRule {
+validate(Dependency): bool
-compatibilityChecker: CompatibilityChecker
}
class CompatibilityChecker {
+isCompatible(Dependency, Dependency): bool
+getCompatibilityInfo(Dependency, Dependency): CompatibilityInfo
-compatibilityDatabase: CompatibilityDatabase
}
DependencyLoader --> Dependency
DependencyLoader --> LoadStrategy
DependencyLoader --> DependencyCache
DependencyResolver --> Dependency
DependencyResolver --> ResolveStrategy
DependencyResolver --> DependencyGraph
DependencyValidator --> Dependency
DependencyValidator --> ValidationRule
DependencyValidator --> CompatibilityChecker
LoadStrategy <|-- LocalLoadStrategy
LoadStrategy <|-- RemoteLoadStrategy
ResolveStrategy <|-- DepthFirstResolveStrategy
ResolveStrategy <|-- BreadthFirstResolveStrategy
ValidationRule <|-- VersionValidationRule
ValidationRule <|-- CompatibilityValidationRule
CompatibilityChecker --> CompatibilityDatabase
RemoteLoadStrategy --> DownloadManager
4.3. 编译配置类图
编译配置类图展示了third_party子模块的编译配置系统，包括编译配置生成器、编译环境准备器、编译命令执行器等核心类。这些类负责编译配置的生成、环境的准备和编译命令的执行，确保了依赖的正确编译。
classDiagram
class BuildConfigGenerator {
+generateConfig(Dependency): BuildConfig
+generateConfigs(list): map
+setTemplateLoader(TemplateLoader): void
-templateLoader: TemplateLoader
-configTemplates: map
}
class BuildEnvironmentPreparer {
+prepareEnvironment(BuildConfig): bool
+cleanupEnvironment()
+getEnvironmentVariables(): map
-environmentVariables: map
-temporaryFiles: list
}
class BuildCommandExecutor {
+executeCommand(BuildConfig): BuildResult
+executeCommands(map): map
+setExecutor(CommandExecutor): void
-executor: CommandExecutor
-commandQueue: BuildCommandQueue
}
class TemplateLoader {
+loadTemplate(string): BuildConfigTemplate
+loadTemplates(string): map
-templatePath: string
-templateCache: map
}
class BuildConfigTemplate {
+getName(): string
+getCompilerFlags(): list
+getLinkerFlags(): list
+getIncludePaths(): list
+getLibraryPaths(): list
+render(Dependency): BuildConfig
-name: string
-compilerFlags: list
-linkerFlags: list
-includePaths: list
-libraryPaths: list
}
class CommandExecutor {
<>
+execute(string): ExecutionResult
}
class LocalCommandExecutor {
+execute(string): ExecutionResult
-workingDirectory: string
}
class RemoteCommandExecutor {
+execute(string): ExecutionResult
-remoteHost: string
-authentication: AuthenticationInfo
}
class BuildResult {
+isSuccess(): bool
+getOutputFiles(): list
+getErrorMessages(): list
+getExecutionTime(): long
-success: bool
-outputFiles: list
-errorMessages: list
-executionTime: long
}
BuildConfigGenerator --> Dependency
BuildConfigGenerator --> BuildConfig
BuildConfigGenerator --> TemplateLoader
BuildEnvironmentPreparer --> BuildConfig
BuildCommandExecutor --> BuildConfig
BuildCommandExecutor --> BuildResult
BuildCommandExecutor --> CommandExecutor
TemplateLoader --> BuildConfigTemplate
BuildConfigTemplate --> BuildConfig
CommandExecutor <|-- LocalCommandExecutor
CommandExecutor <|-- RemoteCommandExecutor
5. 状态机
Apollo third_party子模块的状态机展示了系统在不同阶段的状态转换和处理流程，包括依赖状态机、编译状态机和链接状态机等。这些状态机设计清晰，状态转换明确，便于开发者理解系统的运行机制和行为。
5.1. 依赖生命周期状态机
stateDiagram-v2
[*] --> Unregistered: 依赖未注册
Unregistered --> Registered: 注册依赖
Registered --> Configured: 配置依赖
Configured --> Resolved: 解析依赖
Resolved --> Validated: 验证依赖
Validated --> Loaded: 加载依赖
Loaded --> Compiled: 编译依赖
Compiled --> Linked: 链接依赖
Linked --> Used: 使用依赖
Used --> [*]: 依赖使用完成
Registered --> Error: 注册失败
Configured --> Error: 配置失败
Resolved --> Error: 解析失败
Validated --> Error: 验证失败
Loaded --> Error: 加载失败
Compiled --> Error: 编译失败
Linked --> Error: 链接失败
Error --> [*]: 错误处理完成
state Registered {
[*] --> SettingName: 设置依赖名称
SettingName --> SettingVersion: 名称设置完成
SettingVersion --> SettingType: 版本设置完成
SettingType --> [*]: 类型设置完成
}
state Configured {
[*] --> SettingBuildConfig: 设置构建配置
SettingBuildConfig --> SettingDependencies: 构建配置设置完成
SettingDependencies --> [*]: 依赖关系设置完成
}
state Resolved {
[*] --> ResolvingDependencies: 解析依赖关系
ResolvingDependencies --> BuildingGraph: 依赖关系解析完成
BuildingGraph --> [*]: 依赖图构建完成
}
state Validated {
[*] --> CheckingVersion: 检查版本兼容性
CheckingVersion --> CheckingDependencies: 版本兼容性检查完成
CheckingDependencies --> [*]: 依赖兼容性检查完成
}
5.2. 依赖编译状态机
stateDiagram-v2
[*] --> Idle: 编译空闲
Idle --> Preparing: 准备编译环境
Preparing --> Generating: 生成编译配置
Generating --> Compiling: 编译配置生成完成
Compiling --> Linking: 编译完成
Linking --> Finished: 链接完成
Finished --> [*]: 编译流程完成
Preparing --> Error: 环境准备失败
Generating --> Error: 配置生成失败
Compiling --> Error: 编译失败
Linking --> Error: 链接失败
Error --> [*]: 错误处理完成
state Preparing {
[*] --> CheckingEnvironment: 检查编译环境
CheckingEnvironment --> InstallingDependencies: 环境检查完成
InstallingDependencies --> [*]: 依赖安装完成
}
state Generating {
[*] --> LoadingTemplate: 加载编译模板
LoadingTemplate --> RenderingConfig: 模板加载完成
RenderingConfig --> [*]: 配置渲染完成
}
state Compiling {
[*] --> CompilingSources: 编译源代码
CompilingSources --> GeneratingObjects: 源代码编译完成
GeneratingObjects --> [*]: 目标文件生成完成
}
state Linking {
[*] --> LinkingObjects: 链接目标文件
LinkingObjects --> GeneratingLibrary: 目标文件链接完成
GeneratingLibrary --> [*]: 库文件生成完成
}
5.3. 依赖更新状态机
stateDiagram-v2
[*] --> Checking: 检查更新
Checking --> Available: 发现更新
Checking --> UpToDate: 已是最新版本
Available --> Downloading: 下载更新
Downloading --> Installing: 下载完成
Installing --> Configuring: 安装完成
Configuring --> Compiling: 配置完成
Compiling --> Validating: 编译完成
Validating --> Updated: 验证完成
Updated --> [*]: 更新完成
UpToDate --> [*]: 无需更新
Downloading --> Error: 下载失败
Installing --> Error: 安装失败
Configuring --> Error: 配置失败
Compiling --> Error: 编译失败
Validating --> Error: 验证失败
Error --> [*]: 错误处理完成
state Checking {
[*] --> QueryingServer: 查询服务器
QueryingServer --> ComparingVersions: 服务器查询完成
ComparingVersions --> [*]: 版本比较完成
}
state Downloading {
[*] --> DownloadingFiles: 下载文件
DownloadingFiles --> VerifyingFiles: 文件下载完成
VerifyingFiles --> [*]: 文件验证完成
}
state Installing {
[*] --> ExtractingFiles: 解压文件
ExtractingFiles --> CopyingFiles: 文件解压完成
CopyingFiles --> [*]: 文件复制完成
}
state Validating {
[*] --> TestingFunctionality: 测试功能
TestingFunctionality --> CheckingCompatibility: 功能测试完成
CheckingCompatibility --> [*]: 兼容性检查完成
}
6. 源码分析
6.1. 依赖管理核心代码分析
6.1.1. BUILD文件核心逻辑
python
# 依赖库定义
cc_library(
name = "protobuf",
srcs = glob(["protobuf/**/*.cc"]),
hdrs = glob(["protobuf/**/*.h"]),
includes = ["protobuf/src"],
visibility = ["//visibility:public"],
copts = ["-Wno-sign-compare"],
defines = ["GOOGLE_PROTOBUF_NO_RTTI"],
)
# 依赖库定义
cc_library(
name = "eigen3",
hdrs = glob(["eigen3/**/*.h", "eigen3/**/*.hpp"]),
includes = ["eigen3"],
visibility = ["//visibility:public"],
)
# 依赖库定义
cc_library(
name = "gflags",
srcs = glob(["gflags/**/*.cc"]),
hdrs = glob(["gflags/**/*.h"]),
includes = ["gflags/include"],
visibility = ["//visibility:public"],
copts = ["-Wno-unused-local-typedefs"],
)6.1.2. 依赖配置核心逻辑
python
# 依赖版本配置
PROTOBUF_VERSION = "3.19.1"
EIGEN3_VERSION = "3.3.9"
GFLAGS_VERSION = "2.2.2"
GLOG_VERSION = "0.5.0"
# 依赖兼容性配置
COMPATIBILITY_RULES = {
"protobuf": {
"eigen3": [">=3.3.0"],
"gflags": [">=2.2.0"],
"glog": [">=0.4.0"],
},
"eigen3": {
"protobuf": [">=3.10.0"],
},
}
# 依赖构建配置
BUILD_CONFIGS = {
"protobuf": {
"compiler_flags": ["-Wno-sign-compare"],
"linker_flags": [],
"defines": ["GOOGLE_PROTOBUF_NO_RTTI"],
},
"eigen3": {
"compiler_flags": [],
"linker_flags": [],
"defines": [],
},
"gflags": {
"compiler_flags": ["-Wno-unused-local-typedefs"],
"linker_flags": [],
"defines": [],
},
}6.2. 编译系统核心代码分析
6.2.1. 编译模板核心逻辑
python
# 编译模板定义
BUILD_TEMPLATES = {
"c_library": {
"template": """
cc_library(
name = "{{name}}",
srcs = glob(["{{src_dir}}/**/*.c"]),
hdrs = glob(["{{src_dir}}/**/*.h"]),
includes = ["{{include_dir}}", "{{src_dir}}", "{{src_dir}}/include"],
visibility = ["//visibility:public"],
copts = {{copts}},
defines = {{defines}},
)
""",
"defaults": {
"copts": [],
"defines": [],
},
},
"cpp_library": {
"template": """
cc_library(
name = "{{name}}",
srcs = glob(["{{src_dir}}/**/*.cc", "{{src_dir}}/**/*.cpp"]),
hdrs = glob(["{{src_dir}}/**/*.h", "{{src_dir}}/**/*.hpp"]),
includes = ["{{include_dir}}", "{{src_dir}}", "{{src_dir}}/include"],
visibility = ["//visibility:public"],
copts = {{copts}},
defines = {{defines}},
)
""",
"defaults": {
"copts": [],
"defines": [],
},
},
}6.2.2. 编译命令生成逻辑
python
def generate_build_command(dependency, config):
"""生成编译命令"""
if dependency.type == "c_library":
return generate_c_library_command(dependency, config)
elif dependency.type == "cpp_library":
return generate_cpp_library_command(dependency, config)
elif dependency.type == "python_library":
return generate_python_library_command(dependency, config)
else:
raise ValueError(f"Unknown dependency type: {dependency.type}")
def generate_cpp_library_command(dependency, config):
"""生成C++库编译命令"""
command = [
"g++",
"-c",
"-fPIC",
f"-I{dependency.include_dir}",
]
# 添加编译选项
for flag in config.compiler_flags:
command.append(flag)
# 添加定义
for define in config.defines:
command.append(f"-D{define}")
# 添加源文件
for src_file in dependency.src_files:
command.append(src_file)
return " ".join(command)6.3. 依赖解析核心代码分析
6.3.1. 依赖解析器核心逻辑
python
def resolve_dependencies(dependency, resolved=None, unresolved=None):
"""递归解析依赖关系"""
if resolved is None:
resolved = set()
if unresolved is None:
unresolved = set()
unresolved.add(dependency.name)
for dep in dependency.dependencies:
if dep.name not in resolved:
if dep.name in unresolved:
raise ValueError(f"循环依赖检测到: {dep.name} -> {dependency.name}")
resolve_dependencies(dep, resolved, unresolved)
resolved.add(dependency.name)
unresolved.remove(dependency.name)
return resolved
def build_dependency_graph(dependencies):
"""构建依赖图"""
graph = {}
for dep in dependencies:
graph[dep.name] = {
"dependency": dep,
"dependencies": [d.name for d in dep.dependencies],
}
return graph
def topological_sort(graph):
"""拓扑排序"""
visited = set()
stack = []
def visit(node):
if node not in visited:
visited.add(node)
for dep in graph[node]["dependencies"]:
visit(dep)
stack.append(node)
for node in graph:
visit(node)
return stack[::-1]6.3.2. 版本兼容性检查逻辑
python
def check_compatibility(dependency1, dependency2):
"""检查两个依赖的兼容性"""
if dependency1.name not in COMPATIBILITY_RULES:
return True
rules = COMPATIBILITY_RULES[dependency1.name]
if dependency2.name not in rules:
return True
version_rule = rules[dependency2.name]
return check_version(dependency2.version, version_rule)
def check_version(version, rule):
"""检查版本是否满足规则"""
if isinstance(rule, list):
return any(check_version(version, r) for r in rule)
if rule.startswith(">="):
min_version = rule[2:]
return compare_versions(version, min_version) >= 0
elif rule.startswith(">="):
min_version = rule[2:]
return compare_versions(version, min_version) >= 0
elif rule.startswith("<="):
max_version = rule[2:]
return compare_versions(version, max_version) <= 0
elif rule.startswith(">="):
min_version = rule[2:]
return compare_versions(version, min_version) >= 0
elif rule.startswith("<="):
max_version = rule[2:]
return compare_versions(version, max_version) <= 0
elif rule.startswith("=="):
exact_version = rule[2:]
return compare_versions(version, exact_version) == 0
else:
return True
def compare_versions(v1, v2):
"""比较版本号"""
v1_parts = list(map(int, v1.split(".")))
v2_parts = list(map(int, v2.split(".")))
for i in range(max(len(v1_parts), len(v2_parts))):
v1_part = v1_parts[i] if i < len(v1_parts) else 0
v2_part = v2_parts[i] if i < len(v2_parts) else 0
if v1_part < v2_part:
return -1
elif v1_part > v2_part:
return 1
return 07. 设计模式
7.1. 工厂方法模式
Apollo third_party子模块采用工厂方法模式来创建不同类型的依赖对象，提高了代码的可维护性和扩展性。
python
# 工厂方法模式的实现
class DependencyFactory:
@staticmethod
def create_dependency(dep_type, name, version):
if dep_type == "c_library":
return CLibraryDependency(name, version)
elif dep_type == "cpp_library":
return CppLibraryDependency(name, version)
elif dep_type == "python_library":
return PythonLibraryDependency(name, version)
elif dep_type == "java_library":
return JavaLibraryDependency(name, version)
else:
raise ValueError(f"Unknown dependency type: {dep_type}")
# 依赖库基类
class Dependency:
def __init__(self, name, version):
self.name = name
self.version = version
self.dependencies = []
# 具体依赖库类
class CLibraryDependency(Dependency):
def __init__(self, name, version):
super().__init__(name, version)
self.type = "c_library"
class CppLibraryDependency(Dependency):
def __init__(self, name, version):
super().__init__(name, version)
self.type = "cpp_library"7.2. 策略模式
策略模式用于处理不同类型的依赖加载、解析和编译策略，提高了代码的灵活性和可扩展性。
python
# 策略模式的实现
class LoadStrategy:
def load(self, dependency):
raise NotImplementedError()
class LocalLoadStrategy(LoadStrategy):
def load(self, dependency):
print(f"从本地加载依赖: {dependency.name}")
# 本地加载逻辑
class RemoteLoadStrategy(LoadStrategy):
def load(self, dependency):
print(f"从远程加载依赖: {dependency.name}")
# 远程加载逻辑
class DependencyLoader:
def __init__(self, load_strategy):
self.load_strategy = load_strategy
def load(self, dependency):
self.load_strategy.load(dependency)
# 使用示例
local_loader = DependencyLoader(LocalLoadStrategy())
remote_loader = DependencyLoader(RemoteLoadStrategy())
# 根据需要选择不同的加载策略
dependency = DependencyFactory.create_dependency("cpp_library", "protobuf", "3.19.1")
local_loader.load(dependency)7.3. 观察者模式
观察者模式用于实现依赖更新的通知机制，当依赖版本更新时，自动通知相关模块进行更新。
python
# 观察者模式的实现
class Subject:
def __init__(self):
self.observers = []
def attach(self, observer):
if observer not in self.observers:
self.observers.append(observer)
def detach(self, observer):
try:
self.observers.remove(observer)
except ValueError:
pass
def notify(self, *args, **kwargs):
for observer in self.observers:
observer.update(self, *args, **kwargs)
class Dependency(Subject):
def __init__(self, name, version):
super().__init__()
self.name = name
self._version = version
@property
def version(self):
return self._version
@version.setter
def version(self, value):
if self._version != value:
old_version = self._version
self._version = value
self.notify(old_version, value)
class DependencyObserver:
def update(self, subject, old_version, new_version):
print(f"依赖 {subject.name} 版本更新: {old_version} -> {new_version}")
# 处理版本更新逻辑
# 使用示例
dependency = Dependency("protobuf", "3.19.1")
observer = DependencyObserver()
dependency.attach(observer)
dependency.version = "3.20.0" # 触发更新通知7.4. 单例模式
单例模式用于管理全局的依赖管理器和版本控制器，确保系统中只有一个实例。
python
# 单例模式的实现
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
class DependencyManager(Singleton):
def __init__(self):
if not hasattr(self, "initialized"):
self.dependencies = {}
self.initialized = True
def register(self, dependency):
self.dependencies[dependency.name] = dependency
def get(self, name):
return self.dependencies.get(name)
class VersionController(Singleton):
def __init__(self):
if not hasattr(self, "initialized"):
self.versions = {}
self.initialized = True
def update(self, name, version):
self.versions[name] = version
def get(self, name):
return self.versions.get(name)
# 使用示例
dep_manager1 = DependencyManager()
dep_manager2 = DependencyManager()
print(dep_manager1 is dep_manager2) # 输出: True
version_ctrl1 = VersionController()
version_ctrl2 = VersionController()
print(version_ctrl1 is version_ctrl2) # 输出: True7.5. 模板方法模式
模板方法模式用于定义依赖编译和链接的骨架，具体步骤由子类实现，提高了代码的复用性和可维护性。
python
# 模板方法模式的实现
class BuildProcess:
def build(self, dependency):
self.prepare_environment(dependency)
self.generate_config(dependency)
self.compile(dependency)
self.link(dependency)
self.validate(dependency)
def prepare_environment(self, dependency):
raise NotImplementedError()
def generate_config(self, dependency):
raise NotImplementedError()
def compile(self, dependency):
raise NotImplementedError()
def link(self, dependency):
raise NotImplementedError()
def validate(self, dependency):
raise NotImplementedError()
class CppBuildProcess(BuildProcess):
def prepare_environment(self, dependency):
print(f"准备C++编译环境: {dependency.name}")
# C++环境准备逻辑
def generate_config(self, dependency):
print(f"生成C++编译配置: {dependency.name}")
# C++配置生成逻辑
def compile(self, dependency):
print(f"编译C++源代码: {dependency.name}")
# C++编译逻辑
def link(self, dependency):
print(f"链接C++目标文件: {dependency.name}")
# C++链接逻辑
def validate(self, dependency):
print(f"验证C++库: {dependency.name}")
# C++验证逻辑
class PythonBuildProcess(BuildProcess):
def prepare_environment(self, dependency):
print(f"准备Python编译环境: {dependency.name}")
# Python环境准备逻辑
def generate_config(self, dependency):
print(f"生成Python编译配置: {dependency.name}")
# Python配置生成逻辑
def compile(self, dependency):
print(f"编译Python源代码: {dependency.name}")
# Python编译逻辑
def link(self, dependency):
print(f"链接Python模块: {dependency.name}")
# Python链接逻辑
def validate(self, dependency):
print(f"验证Python模块: {dependency.name}")
# Python验证逻辑
# 使用示例
cpp_dependency = DependencyFactory.create_dependency("cpp_library", "protobuf", "3.19.1")
cpp_builder = CppBuildProcess()
cpp_builder.build(cpp_dependency)
python_dependency = DependencyFactory.create_dependency("python_library", "numpy", "1.21.5")
python_builder = PythonBuildProcess()
python_builder.build(python_dependency)8. 总结
Apollo third_party子模块是Apollo自动驾驶平台的第三方依赖管理系统，集成了上百种开源和商业库，提供基础功能支持。采用集中式管理架构，实现依赖版本统一控制、编译配置标准化和跨平台兼容性，确保各模块间依赖一致性。通过工厂方法、策略、观察者、单例和模板方法等多种设计模式，提高了代码的可维护性和扩展性。third_party子模块为Apollo核心功能提供了稳定可靠的基础支撑，是Apollo平台的重要组成部分。