SpringBoot与Artemis整合，实现航空行李追踪消息中枢系统

航空行李追踪系统技术方案与实现

一、业务背景与问题分析

问题现状

• 数据孤岛：航空公司、机场各系统间缺乏统一数据接口
• 追踪盲区：行李从值机到装载存在多个监控断点
• 响应滞后：异常发现依赖人工报告，平均响应时间超过1小时
• 成本高昂：全球航空业每年行李丢失赔偿成本约25亿美元

业务需求

1. 全链路可视化：行李从值机到提取的全流程状态监控
2. 实时告警：异常状态（延误、错运、丢失）自动触发告警
3. 数据追溯：完整事件日志支持问题排查与责任认定
4. 系统集成：兼容现有值机、安检、分拣等异构系统

二、技术选型：为什么选择ActiveMQ Artemis

2.1 性能对比分析

指标	ActiveMQ Classic	ActiveMQ Artemis	Kafka	RocketMQ
吞吐量	5-10k TPS	100k+ TPS	500k+ TPS	100k+ TPS
平均延迟	10-50ms	< 5ms	10-25ms	< 10ms
事务支持	✓	✓ (XA/JTA)	△ (有限)	△
协议支持	AMQP, OpenWire	AMQP, MQTT, STOMP	自定义协议	自定义协议
消息持久化	KahaDB	高性能Journal	分区日志	文件存储

2.2 Artemis核心优势

2.2.1 高性能架构

• 异步I/O：基于Netty非阻塞I/O，支持10万+并发连接
• 零拷贝：减少内存复制开销，提升吞吐量
• 智能分页：自动管理大消息内存，防止内存溢出

2.2.2 航空场景适配性

// Artemis关键配置示例
@Configuration
public class ArtemisConfig {
    @Bean
    public ArtemisConnectionFactory connectionFactory() {
        // 航空场景要求的高可用配置
        Map<String, Object> transportParams = new HashMap<>();
        transportParams.put("reconnectAttempts", 10);    // 重连次数
        transportParams.put("retryInterval", 2000);      // 重试间隔(ms)
        transportParams.put("connectionTTL", 60000);     // 连接存活时间
        
        return new ArtemisConnectionFactory(
            "(tcp://primary:61616,tcp://backup:61616)?ha=true",
            "luggageUser", "luggagePass123"
        );
    }
}

2.2.3 数据安全保障

• 持久化保证：同步写入Journal后确认，RPO=0
• 事务支持：XA分布式事务，确保"已发送即已处理"
• 消息重投：消费失败自动重试，DLQ处理"毒药消息"

2.2.4 高可用设计

# Artemis集群配置（生产环境）
nodes:
  primary:
    url: tcp://artemis-node1:61616
    role: primary
    backup: node2
  backup:
    url: tcp://artemis-node2:61616  
    role: backup
    replication: live-backup
  monitor:
    url: tcp://artemis-node3:61616
    role: monitor
    
# 故障切换策略
failover:
  check-period: 5000    # 健康检查间隔(ms)
  failback-delay: 10000 # 主节点恢复后延迟切换
  quorum-size: 2        # 最小存活节点数

三、系统架构设计

3.1 整体架构

┌─────────────────────────────────────────────────────────┐
│                   行李追踪应用层                          │
├─────────────┬─────────────┬─────────────┬─────────────┤
│  值机系统    │  安检系统    │  分拣系统    │  查询终端    │
│  (Java)     │  (C++)      │  (Python)   │  (.NET)     │
└──────┬──────┴──────┬──────┴──────┬──────┴──────┬──────┘
       │              │             │              │
       └──────────────┼─────────────┼──────────────┘
                      │             │
        ┌─────────────▼─────────────▼─────────────┐
        │       ActiveMQ Artemis 消息中间件         │
        │  ┌──────────┐  ┌──────────┐  ┌──────────┐│
        │  │跟踪队列   │  │警报队列   │  │重试队列   ││
        │  │(持久化)   │  │(高优先级) │  │(延迟投递) ││
        │  └────┬─────┘  └────┬─────┘  └────┬─────┘│
        └───────┼──────────────┼─────────────┼──────┘
                │              │             │
        ┌───────▼──────────────▼─────────────▼──────┐
        │              行李状态处理器                  │
        │  ┌──────────┐  ┌──────────┐  ┌──────────┐│
        │  │状态聚合   │  │规则引擎   │  │告警生成   ││
        │  └────┬─────┘  └────┬─────┘  └────┬─────┘│
        └───────┼──────────────┼─────────────┼──────┘
                │              │             │
        ┌───────▼──────────────▼─────────────▼──────┐
        │               数据存储层                    │
        │  ┌──────────┐  ┌──────────┐  ┌──────────┐│
        │  │Redis缓存  │  │MySQL主库 │  │ES索引库   ││
        │  │(实时查询) │  │(持久存储) │  │(历史搜索) ││
        │  └──────────┘  └──────────┘  └──────────┘│
        └───────────────────────────────────────────┘

3.2 消息队列设计

3.2.1 队列拓扑

public class QueueTopology {
    // 核心业务队列
    public static final String TRACKING_QUEUE = "luggage.tracking.queue";
    public static final String ALERT_QUEUE = "luggage.alert.queue";
    public static final String RETRY_QUEUE = "luggage.retry.queue";
    
    // 延迟队列（用于超时检测）
    public static final String DELAY_QUEUE = "luggage.delay.queue";
    
    // 死信队列（处理无法消费的消息）
    public static final String DLQ = "ActiveMQ.DLQ";
    
    // 虚拟主题（用于广播通知）
    public static final String NOTIFICATION_TOPIC = "VirtualTopic.Luggage.Notifications";
}

3.2.2 消息优先级策略

@Service
public class PriorityMessageService {
    
    // 行李状态优先级定义
    private enum MessagePriority {
        CRITICAL(9),    // 丢失、错运
        HIGH(6),        // 延误、安检异常
        NORMAL(3),      // 常规状态更新
        LOW(0);         // 历史数据同步
        
        private final int value;
        MessagePriority(int value) { this.value = value; }
        public int getValue() { return value; }
    }
    
    public void sendWithPriority(LuggageTrackingEvent event) {
        int priority = calculatePriority(event.getStatus());
        
        jmsTemplate.execute(session -> {
            Message message = session.createObjectMessage(event);
            message.setJMSPriority(priority);
            message.setJMSTimestamp(System.currentTimeMillis());
            message.setStringProperty("LUGGAGE_ID", event.getLuggageId());
            message.setStringProperty("FLIGHT_NUMBER", event.getFlightNumber());
            
            return session.createProducer(destination)
                .send(message);
        });
    }
    
    private int calculatePriority(String status) {
        switch (status.toUpperCase()) {
            case "LOST":
            case "MISROUTED":
                return MessagePriority.CRITICAL.getValue();
            case "DELAYED":
            case "SECURITY_HOLD":
                return MessagePriority.HIGH.getValue();
            default:
                return MessagePriority.NORMAL.getValue();
        }
    }
}

四、核心功能实现

4.1 行李状态模型增强

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LuggageTrackingEvent {
    // 基础标识
    private String luggageId;          // 行李唯一标识
    private String flightNumber;       // 航班号
    private String passengerId;        // 乘客ID
    
    // 位置信息
    private Location location;         // GPS/WiFi定位
    private String checkpoint;         // 检查点(值机/安检/装载/卸载)
    private String conveyorId;         // 传送带编号
    private String containerId;        // 集装箱编号
    
    // 状态信息
    private LuggageStatus status;      // 枚举状态
    private String subStatus;          // 子状态
    private LocalDateTime eventTime;   // 事件发生时间
    private LocalDateTime expectedTime; // 预期时间
    
    // 传感器数据
    private Double weight;             // 重量(kg)
    private Double temperature;        // 温度(°C)
    private Boolean isDamaged;         // 是否损坏
    
    // 业务上下文
    private String operatorId;         // 操作员ID
    private String equipmentId;        // 设备ID
    private String sourceSystem;       // 来源系统
}

// 状态枚举定义
public enum LuggageStatus {
    CHECKED_IN("已值机"),
    SECURITY_CHECKED("安检通过"),
    LOADING("装载中"),
    LOADED("已装载"),
    UNLOADING("卸载中"),
    ON_CONVEYOR("传送带上"),
    READY_FOR_PICKUP("待提取"),
    PICKED_UP("已提取"),
    DELAYED("延误"),
    MISROUTED("错运"),
    LOST("丢失"),
    DAMAGED("损坏");
    
    private final String description;
    LuggageStatus(String desc) { this.description = desc; }
    public String getDesc() { return description; }
}

4.2 智能告警引擎

@Component
public class AlertEngine {
    
    @Autowired
    private RuleRepository ruleRepository;
    
    @Autowired
    private JmsTemplate jmsTemplate;
    
    /**
     * 基于规则的告警检测
     */
    @JmsListener(destination = QueueTopology.TRACKING_QUEUE)
    public void processTrackingEvent(LuggageTrackingEvent event) {
        // 1. 状态突变检测
        checkStatusTransition(event);
        
        // 2. 超时检测
        checkTimeout(event);
        
        // 3. 路径异常检测
        checkRoutingAnomaly(event);
        
        // 4. 模式匹配告警
        List<AlertRule> matchedRules = matchRules(event);
        
        if (!matchedRules.isEmpty()) {
            generateAlerts(event, matchedRules);
        }
    }
    
    /**
     * 超时检测逻辑
     */
    private void checkTimeout(LuggageTrackingEvent event) {
        LocalDateTime expectedTime = calculateExpectedTime(event);
        
        if (LocalDateTime.now().isAfter(expectedTime.plusMinutes(15))) {
            // 发送到延迟队列，用于后续处理
            sendToDelayQueue(event, "CHECKPOINT_TIMEOUT");
        }
    }
    
    /**
     * 路径验证
     */
    private void checkRoutingAnomaly(LuggageTrackingEvent event) {
        List<String> expectedPath = getExpectedPath(event.getFlightNumber());
        String currentCheckpoint = event.getCheckpoint();
        
        if (!expectedPath.contains(currentCheckpoint)) {
            // 路径异常告警
            sendAlert(event, "ROUTING_ANOMALY", 
                "行李出现在非预期位置: " + currentCheckpoint);
        }
    }
}

4.3 实时状态聚合

@Service
@Slf4j
public class StatusAggregator {
    
    private final ConcurrentMap<String, LuggageJourney> journeys = 
        new ConcurrentHashMap<>();
    
    /**
     * 更新行李旅程状态
     */
    public void updateJourney(LuggageTrackingEvent event) {
        String luggageId = event.getLuggageId();
        
        journeys.compute(luggageId, (key, existingJourney) -> {
            if (existingJourney == null) {
                return new LuggageJourney(event);
            } else {
                existingJourney.addEvent(event);
                return existingJourney;
            }
        });
        
        // 发布状态更新到WebSocket
        publishRealTimeUpdate(event);
    }
    
    /**
     * 获取行李全链路状态
     */
    public LuggageJourney getFullJourney(String luggageId) {
        LuggageJourney journey = journeys.get(luggageId);
        
        if (journey == null) {
            // 从持久化存储中恢复
            journey = loadFromPersistence(luggageId);
            if (journey != null) {
                journeys.put(luggageId, journey);
            }
        }
        
        return journey;
    }
    
    /**
     * WebSocket实时推送
     */
    private void publishRealTimeUpdate(LuggageTrackingEvent event) {
        SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor
            .create(SimpMessageType.MESSAGE);
        
        accessor.setSessionId("system");
        accessor.setLeaveMutable(true);
        
        String destination = "/topic/luggage/" + event.getLuggageId();
        String payload = convertToJSON(event);
        
        messagingTemplate.convertAndSend(destination, payload, accessor.getMessageHeaders());
    }
}

五、高级特性实现

5.1 分布式事务管理

@Service
@Transactional
public class TransactionalTrackingService {
    
    @Autowired
    private JmsTemplate jmsTemplate;
    
    @Autowired
    private LuggageRepository luggageRepository;
    
    /**
     * XA分布式事务：数据库和消息队列的原子操作
     */
    @Transactional(rollbackFor = Exception.class)
    @JmsListener(destination = QueueTopology.TRACKING_QUEUE)
    public void processWithTransaction(LuggageTrackingEvent event) {
        try {
            // 1. 更新数据库状态
            LuggageEntity entity = luggageRepository.findByLuggageId(event.getLuggageId());
            entity.setStatus(event.getStatus().name());
            entity.setLastUpdateTime(LocalDateTime.now());
            luggageRepository.save(entity);
            
            // 2. 发送下游通知（同一事务）
            if (requiresNotification(event)) {
                jmsTemplate.convertAndSend(
                    QueueTopology.NOTIFICATION_TOPIC, 
                    buildNotification(event)
                );
            }
            
            // 3. 记录审计日志
            auditLogService.logEvent(event);
            
        } catch (Exception e) {
            log.error("Transaction failed for luggage: {}", event.getLuggageId(), e);
            // 事务会自动回滚，包括消息消费
            throw e;
        }
    }
}

5.2 消息重试与死信处理

@Configuration
public class RetryConfiguration {
    
    @Bean
    public RedeliveryPolicy redeliveryPolicy() {
        RedeliveryPolicy policy = new RedeliveryPolicy();
        policy.setInitialRedeliveryDelay(1000);     // 初始延迟1秒
        policy.setBackOffMultiplier(2);             // 指数退避
        policy.setUseExponentialBackOff(true);
        policy.setMaximumRedeliveries(5);           // 最大重试5次
        policy.setMaximumRedeliveryDelay(60000);    // 最大延迟60秒
        return policy;
    }
    
    @Bean
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory(
            ConnectionFactory connectionFactory) {
        DefaultJmsListenerContainerFactory factory = 
            new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setSessionTransacted(true);
        
        // 配置错误处理器
        factory.setErrorHandler(t -> {
            log.error("Message processing failed", t);
            // 发送到死信队列进行分析
            sendToDLQ(t);
        });
        
        return factory;
    }
}

5.3 性能监控与指标

@Component
@Slf4j
public class PerformanceMonitor {
    
    private final MeterRegistry meterRegistry;
    
    // 关键性能指标
    private final Timer messageProcessingTimer;
    private final Counter processedMessagesCounter;
    private final DistributionSummary messageSizeSummary;
    
    public PerformanceMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        // 初始化指标
        this.messageProcessingTimer = Timer.builder("luggage.message.processing.time")
            .description("消息处理时间")
            .publishPercentiles(0.5, 0.95, 0.99)
            .register(meterRegistry);
            
        this.processedMessagesCounter = Counter.builder("luggage.messages.processed")
            .description("处理的消息总数")
            .register(meterRegistry);
    }
    
    @JmsListener(destination = QueueTopology.TRACKING_QUEUE)
    public void monitorProcessing(LuggageTrackingEvent event) {
        processedMessagesCounter.increment();
        
        long startTime = System.currentTimeMillis();
        
        try {
            // 实际处理逻辑...
            
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            messageProcessingTimer.record(duration, TimeUnit.MILLISECONDS);
            
            // 记录延迟指标
            recordLatencyMetrics(event, duration);
        }
    }
    
    private void recordLatencyMetrics(LuggageTrackingEvent event, long processingTime) {
        Tags tags = Tags.of(
            "checkpoint", event.getCheckpoint(),
            "status", event.getStatus().name(),
            "source", event.getSourceSystem()
        );
        
        meterRegistry.timer("luggage.processing.latency", tags)
            .record(processingTime, TimeUnit.MILLISECONDS);
    }
}

六、部署与运维

6.1 Docker部署配置

# docker-compose-artemis.yml
version: '3.8'
services:
  artemis-primary:
    image: apache/activemq-artemis:latest
    container_name: artemis-primary
    ports:
      - "61616:61616"   # Core protocol
      - "8161:8161"     # Web console
      - "5672:5672"     # AMQP
      - "1883:1883"     # MQTT
    environment:
      - ARTEMIS_USERNAME=admin
      - ARTEMIS_PASSWORD=securePass123
      - ANONYMOUS_LOGIN=false
    volumes:
      - ./artemis-data:/var/lib/artemis/data
      - ./artemis-etc:/var/lib/artemis/etc
    networks:
      - luggage-network
    command: >
      /opt/artemis/bin/artemis create
      --user admin
      --password securePass123
      --cluster-user clusterUser
      --cluster-password clusterPass123
      --require-login
      --ssl-key /var/lib/artemis/etc/server-key.pem
      --ssl-trust /var/lib/artemis/etc/client-trust.pem
      --host primary.artemis.luggage.local
      --relax-jolokia
      --data /var/lib/artemis/data
  
  artemis-backup:
    image: apache/activemq-artemis:latest
    container_name: artemis-backup
    depends_on:
      - artemis-primary
    environment:
      - ARTEMIS_USERNAME=admin
      - ARTEMIS_PASSWORD=securePass123
    volumes:
      - ./backup-data:/var/lib/artemis/data
    networks:
      - luggage-network
    command: >
      /opt/artemis/bin/artemis create
      --user admin
      --password securePass123
      --cluster-user clusterUser
      --cluster-password clusterPass123
      --require-login
      --host backup.artemis.luggage.local
      --replicated
      --slave
      --data /var/lib/artemis/data
  
  luggage-tracker:
    build: .
    container_name: luggage-tracking-service
    ports:
      - "8080:8080"
    environment:
      - SPRING_ARTEMIS_BROKER_URL=failover:(tcp://artemis-primary:61616,tcp://artemis-backup:61616)?randomize=false
      - SPRING_ARTEMIS_USER=luggageApp
      - SPRING_ARTEMIS_PASSWORD=appPass123
    depends_on:
      - artemis-primary
    networks:
      - luggage-network
    restart: unless-stopped

networks:
  luggage-network:
    driver: bridge

6.2 监控告警配置

# prometheus.yml
scrape_configs:
  - job_name: 'artemis'
    static_configs:
      - targets: ['artemis-primary:8161', 'artemis-backup:8161']
    metrics_path: '/metrics'
    
  - job_name: 'luggage-tracker'
    static_configs:
      - targets: ['luggage-tracker:8080']
    metrics_path: '/actuator/prometheus'

# alert-rules.yml
groups:
  - name: luggage_alerts
    rules:
      - alert: HighMessageLatency
        expr: histogram_quantile(0.95, rate(luggage_message_processing_time_seconds_bucket[5m])) > 0.1
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "消息处理延迟超过阈值"
          description: "行李消息处理P95延迟超过100ms"
      
      - alert: QueueBacklog
        expr: artemis_queue_message_count{queue="luggage.tracking.queue"} > 10000
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "消息队列积压严重"
          description: "行李追踪队列积压超过10000条消息"
      
      - alert: ConsumerDisconnected
        expr: artemis_consumer_count{queue="luggage.tracking.queue"} < 1
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "消费者连接断开"
          description: "行李追踪队列无消费者连接"

6.3 安全配置

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/api/luggage/status/**").hasAnyRole("AGENT", "SUPERVISOR")
                .antMatchers("/api/luggage/alert/**").hasRole("SUPERVISOR")
                .antMatchers("/api/luggage/track").hasRole("SYSTEM")
                .anyRequest().authenticated()
            .and()
            .httpBasic()
            .and()
            .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
    
    @Bean
    public ConnectionFactory securedConnectionFactory() {
        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory();
        factory.setBrokerURL("tcp://artemis:61616");
        factory.setUser("luggage-service");
        factory.setPassword(decryptPassword());
        
        // SSL配置
        factory.setUseGlobalPools(false);
        factory.setTransportConfigurations(
            Arrays.asList(
                new TransportConfiguration(
                    NettyConnectorFactory.class.getName(),
                    new HashMap<String, Object>() {{
                        put("host", "artemis");
                        put("port", 61616);
                        put("sslEnabled", true);
                        put("trustStorePath", "/certs/client.truststore");
                        put("trustStorePassword", "changeit");
                    }}
                )
            )
        );
        
        return factory;
    }
}

七、性能优化建议

7.1 Artemis优化配置

# broker.xml关键配置
<configuration>
    <core xmlns="urn:activemq:core">
        <!-- 内存优化 -->
        <global-max-size>1GB</global-max-size>
        <journal-file-size>100MB</journal-file-size>
        <journal-min-files>10</journal-min-files>
        
        <!-- 持久化优化 -->
        <journal-type>ASYNCIO</journal-type>
        <journal-sync-transactional>true</journal-sync-transactional>
        <journal-sync-non-transactional>false</journal-sync-non-transactional>
        
        <!-- 网络优化 -->
        <connectors>
            <connector name="netty">tcp://0.0.0.0:61616?tcpSendBufferSize=1048576;tcpReceiveBufferSize=1048576</connector>
        </connectors>
        
        <!-- 队列配置 -->
        <address-settings>
            <address-setting match="luggage.#">
                <max-size-bytes>500000000</max-size-bytes>
                <page-size-bytes>10000000</page-size-bytes>
                <address-full-policy>PAGE</address-full-policy>
                <redelivery-delay>1000</redelivery-delay>
                <max-delivery-attempts>5</max-delivery-attempts>
            </address-setting>
        </address-settings>
    </core>
</configuration>

7.2 消费者并发优化

@Configuration
public class ConsumerOptimizationConfig {
    
    @Bean
    public DefaultJmsListenerContainerFactory optimizedContainerFactory(
            ConnectionFactory connectionFactory) {
        DefaultJmsListenerContainerFactory factory = 
            new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        
        // 根据业务负载动态调整并发度
        int minConcurrent = Integer.parseInt(env.getProperty("jms.consumer.min", "5"));
        int maxConcurrent = Integer.parseInt(env.getProperty("jms.consumer.max", "20"));
        
        factory.setConcurrency(minConcurrent + "-" + maxConcurrent);
        
        // 优化配置
        factory.setSessionTransacted(true);
        factory.setSessionAcknowledgeMode(Session.SESSION_TRANSACTED);
        factory.setCacheLevelName("CACHE_CONSUMER");
        factory.setIdleTaskExecutionLimit(10);
        factory.setIdleConsumerLimit(5);
        
        return factory;
    }
    
    @Bean
    public ThreadPoolTaskExecutor jmsTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("jms-consumer-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

八、业务价值与效果

8.1 预期业务指标改善

指标	改善前	改善后	改善幅度
行李丢失率	0.5%	< 0.1%	↓ 80%
异常发现时间	60分钟	< 5分钟	↓ 91.7%
处理响应时间	120分钟	< 30分钟	↓ 75%
旅客投诉率	1.2%	< 0.3%	↓ 75%
赔偿成本	$25亿/年	< $5亿/年	↓ 80%

8.2 扩展应用场景

1. 行李预测性维护

   • 基于历史数据预测行李处理瓶颈
   • 提前调配地勤资源

2. 旅客服务升级

   • 实时推送行李状态到旅客APP
   • 自动生成延误证明和赔偿申请

3. 机场运营优化

   • 行李流线分析优化
   • 设备使用率监控

九、总结

本系统通过ActiveMQ Artemis构建的实时行李追踪平台，成功解决了航空行李运输中的关键痛点：

1. 技术先进性：Artemis的高性能、多协议支持完美适配航空异构系统
2. 业务贴合性：全链路追踪、实时告警、数据追溯满足航空业SLA要求
3. 可扩展性：模块化设计支持未来功能扩展
4. 高可用性：集群部署、灾备方案确保业务连续性

系统实施后预计可大幅降低行李丢失率和运营成本，提升旅客满意度，为航空公司的数字化转型提供有力支撑。