// 示例：适配器模式基本结构
public interface NotificationChannel {
    SendResult send(NotificationMessage message);
    ChannelStatus getStatus();
    void configure(ChannelConfig config);
    List<DeliveryReceipt> getDeliveryReceipts(String startTime, String endTime);
}

// 具体供应商适配器
public class SmsChannelAdapter implements NotificationChannel {
    private final SmsServiceProvider serviceProvider;
    
    public SmsChannelAdapter(SmsServiceProvider serviceProvider) {
        this.serviceProvider = serviceProvider;
    }
    
    @Override
    public SendResult send(NotificationMessage message) {
        // 将统一消息格式转换为供应商特定格式
        SmsMessage smsMessage = convertToSmsMessage(message);
        
        // 调用供应商API发送消息
        SmsSendResponse response = serviceProvider.sendSms(smsMessage);
        
        // 将供应商响应转换为统一格式
        return convertToSendResult(response);
    }
    
    @Override
    public ChannelStatus getStatus() {
        SmsServiceStatus status = serviceProvider.getServiceStatus();
        return convertToChannelStatus(status);
    }
    
    // 其他方法实现...
}

关键设计要点：

接口抽象：定义统一的通道接口
实现转换：在适配器中实现格式转换
双向适配：支持双向的数据格式转换
状态管理：统一管理通道状态信息

适配器类型

// 示例：不同类型的适配器实现

// 类适配器（通过继承实现）
public class EmailChannelClassAdapter extends EmailServiceProvider 
                                     implements NotificationChannel {
    @Override
    public SendResult send(NotificationMessage message) {
        EmailMessage emailMessage = convertToEmailMessage(message);
        EmailSendResponse response = super.sendEmail(emailMessage);
        return convertToSendResult(response);
    }
    
    // 其他方法实现...
}

// 对象适配器（通过组合实现）
public class PushChannelObjectAdapter implements NotificationChannel {
    private final PushServiceProvider pushServiceProvider;
    
    public PushChannelObjectAdapter(PushServiceProvider pushServiceProvider) {
        this.pushServiceProvider = pushServiceProvider;
    }
    
    @Override
    public SendResult send(NotificationMessage message) {
        PushMessage pushMessage = convertToPushMessage(message);
        PushSendResponse response = pushServiceProvider.sendPush(pushMessage);
        return convertToSendResult(response);
    }
    
    // 其他方法实现...
}

关键实现要点：

类适配器：通过继承实现适配
对象适配器：通过组合实现适配
双向适配：支持双向的接口转换
灵活选择：根据具体场景选择适配器类型

统一接口设计

核心操作接口

// 示例：统一通知通道接口设计
public interface NotificationChannel {
    
    // 消息发送
    SendResult send(NotificationMessage message);
    
    // 批量发送
    BatchSendResult sendBatch(List<NotificationMessage> messages);
    
    // 消息查询
    MessageStatus queryMessageStatus(String messageId);
    
    // 通道状态
    ChannelStatus getChannelStatus();
    
    // 通道配置
    void configure(ChannelConfig config);
    
    // 回执获取
    List<DeliveryReceipt> getDeliveryReceipts(String startTime, String endTime);
    
    // 统计信息
    ChannelStatistics getStatistics(String startTime, String endTime);
    
    // 健康检查
    HealthCheckResult healthCheck();
    
    // 资源清理
    void cleanup();
}

// 统一消息格式
public class NotificationMessage {
    private String messageId;
    private Receiver receiver;
    private String content;
    private Map<String, Object> variables;
    private MessagePriority priority;
    private Date scheduledTime;
    private Map<String, Object> extendedProperties;
    
    // 构造函数、getter和setter方法...
}

// 发送结果统一格式
public class SendResult {
    private String messageId;
    private String channelMessageId;
    private SendStatus status;
    private String errorCode;
    private String errorMessage;
    private Date sendTime;
    private Map<String, Object> providerResponse;
    
    // 构造函数、getter和setter方法...
}

关键接口要点：

操作完整：涵盖通道的核心操作功能
格式统一：定义统一的数据格式
扩展支持：支持扩展属性和自定义配置
状态明确：明确定义各种状态和结果

配置管理接口

// 示例：通道配置管理
public class ChannelConfig {
    private String channelId;
    private String channelType;
    private boolean enabled;
    private int priority;
    private Map<String, Object> providerConfig;
    private Map<String, Object> rateLimitConfig;
    private Map<String, Object> failoverConfig;
    private List<String> supportedFeatures;
    
    // 构造函数、getter和setter方法...
}

// 供应商特定配置
public class ProviderConfig {
    private String apiKey;
    private String apiSecret;
    private String endpoint;
    private String senderId;
    private Map<String, Object> customProperties;
    private SSLConfig sslConfig;
    private ProxyConfig proxyConfig;
    
    // 构造函数、getter和setter方法...
}

关键配置要点：

灵活配置：支持灵活的配置管理
安全存储：安全存储敏感配置信息
动态更新：支持配置的动态更新
版本管理：支持配置的版本管理

供应商接入实现

不同类型的供应商需要不同的适配器实现：

短信通道适配器

国内短信供应商

// 示例：国内短信供应商适配器
@Component
public class DomesticSmsAdapter implements NotificationChannel {
    
    private final DomesticSmsService domesticSmsService;
    private final ChannelConfig channelConfig;
    
    public DomesticSmsAdapter(DomesticSmsService domesticSmsService, 
                            ChannelConfig channelConfig) {
        this.domesticSmsService = domesticSmsService;
        this.channelConfig = channelConfig;
        initializeService();
    }
    
    private void initializeService() {
        // 初始化供应商服务
        ProviderConfig providerConfig = channelConfig.getProviderConfig();
        domesticSmsService.setApiKey(providerConfig.getApiKey());
        domesticSmsService.setApiSecret(providerConfig.getApiSecret());
        domesticSmsService.setEndpoint(providerConfig.getEndpoint());
        domesticSmsService.setSenderId(providerConfig.getSenderId());
    }
    
    @Override
    public SendResult send(NotificationMessage message) {
        try {
            // 转换消息格式
            DomesticSmsMessage smsMessage = convertToDomesticSmsMessage(message);
            
            // 发送短信
            DomesticSmsResponse response = domesticSmsService.sendSms(smsMessage);
            
            // 转换响应格式
            return convertToSendResult(response);
        } catch (Exception e) {
            log.error("发送短信失败: messageId={}", message.getMessageId(), e);
            return createFailedResult(message.getMessageId(), "SEND_FAILED", e.getMessage());
        }
    }
    
    private DomesticSmsMessage convertToDomesticSmsMessage(NotificationMessage message) {
        DomesticSmsMessage smsMessage = new DomesticSmsMessage();
        smsMessage.setPhoneNumber(message.getReceiver().getValue());
        smsMessage.setContent(message.getContent());
        smsMessage.setScheduledTime(message.getScheduledTime());
        
        // 处理签名
        String signature = getSignature(message);
        smsMessage.setSignature(signature);
        
        // 处理模板
        if (message.getTemplateId() != null) {
            smsMessage.setTemplateId(message.getTemplateId());
            smsMessage.setTemplateVariables(message.getVariables());
        }
        
        return smsMessage;
    }
    
    private SendResult convertToSendResult(DomesticSmsResponse response) {
        SendResult result = new SendResult();
        result.setMessageId(response.getMessageId());
        result.setChannelMessageId(response.getChannelMessageId());
        result.setStatus(convertStatus(response.getStatus()));
        result.setErrorCode(response.getErrorCode());
        result.setErrorMessage(response.getErrorMessage());
        result.setSendTime(response.getSendTime());
        result.setProviderResponse(convertProviderResponse(response));
        return result;
    }
    
    private SendStatus convertStatus(String status) {
        switch (status) {
            case "SUCCESS": return SendStatus.SUCCESS;
            case "FAILED": return SendStatus.FAILED;
            case "PENDING": return SendStatus.PENDING;
            default: return SendStatus.UNKNOWN;
        }
    }
}

关键实现要点：

格式转换：处理不同格式间的转换
签名处理：处理短信签名的特殊要求
模板支持：支持模板变量的处理
异常处理：完善的异常处理机制

国际短信供应商

// 示例：国际短信供应商适配器
@Component
public class InternationalSmsAdapter implements NotificationChannel {
    
    private final InternationalSmsService internationalSmsService;
    
    @Override
    public SendResult send(NotificationMessage message) {
        try {
            InternationalSmsMessage smsMessage = convertToInternationalSmsMessage(message);
            InternationalSmsResponse response = internationalSmsService.sendSms(smsMessage);
            return convertToSendResult(response);
        } catch (Exception e) {
            log.error("发送国际短信失败: messageId={}", message.getMessageId(), e);
            return createFailedResult(message.getMessageId(), "INTERNATIONAL_SEND_FAILED", e.getMessage());
        }
    }
    
    private InternationalSmsMessage convertToInternationalSmsMessage(NotificationMessage message) {
        InternationalSmsMessage smsMessage = new InternationalSmsMessage();
        smsMessage.setPhoneNumber(formatInternationalNumber(message.getReceiver().getValue()));
        smsMessage.setContent(message.getContent());
        smsMessage.setCountryCode(extractCountryCode(message.getReceiver().getValue()));
        smsMessage.setSenderId(getSenderId());
        
        // 国际短信特殊处理
        if (message.getContent().length() > 160) {
            smsMessage.setLongSms(true);
        }
        
        return smsMessage;
    }
    
    private String formatInternationalNumber(String phoneNumber) {
        // 格式化国际号码，添加+号前缀
        if (!phoneNumber.startsWith("+")) {
            return "+" + phoneNumber;
        }
        return phoneNumber;
    }
    
    private String extractCountryCode(String phoneNumber) {
        // 从号码中提取国家代码
        if (phoneNumber.startsWith("+")) {
            // 简单实现，实际需要更复杂的逻辑
            return phoneNumber.substring(1, 3);
        }
        return "86"; // 默认中国
    }
}

关键实现要点：

国际格式：处理国际号码格式要求
国家代码：正确处理国家代码
长短信：支持长短信的特殊处理
字符编码：处理不同字符编码要求

邮件通道适配器

SMTP邮件适配器

// 示例：SMTP邮件适配器
@Component
public class SmtpEmailAdapter implements NotificationChannel {
    
    private final JavaMailSender mailSender;
    private final ChannelConfig channelConfig;
    
    @Override
    public SendResult send(NotificationMessage message) {
        try {
            MimeMessage mimeMessage = createMimeMessage(message);
            mailSender.send(mimeMessage);
            
            return createSuccessResult(message.getMessageId());
        } catch (Exception e) {
            log.error("发送邮件失败: messageId={}", message.getMessageId(), e);
            return createFailedResult(message.getMessageId(), "EMAIL_SEND_FAILED", e.getMessage());
        }
    }
    
    private MimeMessage createMimeMessage(NotificationMessage message) throws Exception {
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
        
        // 设置基本信息
        helper.setTo(message.getReceiver().getValue());
        helper.setFrom(getFromAddress());
        helper.setSubject(message.getSubject());
        
        // 设置内容
        if (message.isHtmlContent()) {
            helper.setText(message.getContent(), true);
        } else {
            helper.setText(message.getContent());
        }
        
        // 添加附件
        if (message.getAttachments() != null) {
            for (Attachment attachment : message.getAttachments()) {
                helper.addAttachment(attachment.getFilename(), 
                                   new ByteArrayResource(attachment.getContent()));
            }
        }
        
        // 设置发送时间
        if (message.getScheduledTime() != null) {
            mimeMessage.setSentDate(message.getScheduledTime());
        }
        
        return mimeMessage;
    }
    
    private String getFromAddress() {
        ProviderConfig config = channelConfig.getProviderConfig();
        return config.getCustomProperties().get("fromAddress").toString();
    }
}

关键实现要点：

MIME消息：创建标准的MIME邮件消息
HTML支持：支持HTML格式邮件
附件处理：支持邮件附件功能
发送时间：支持定时发送功能

第三方邮件服务适配器

// 示例：第三方邮件服务适配器（如SendGrid）
@Component
public class SendGridEmailAdapter implements NotificationChannel {
    
    private final SendGrid sendGrid;
    private final ChannelConfig channelConfig;
    
    @Override
    public SendResult send(NotificationMessage message) {
        try {
            Mail mail = createSendGridMail(message);
            Request request = new Request();
            request.setMethod(Method.POST);
            request.setEndpoint("mail/send");
            request.setBody(mail.build());
            
            Response response = sendGrid.api(request);
            
            if (response.getStatusCode() == 202) {
                return createSuccessResult(message.getMessageId());
            } else {
                return createFailedResult(message.getMessageId(), 
                                        "SENDGRID_ERROR", 
                                        response.getBody());
            }
        } catch (Exception e) {
            log.error("通过SendGrid发送邮件失败: messageId={}", message.getMessageId(), e);
            return createFailedResult(message.getMessageId(), "SENDGRID_SEND_FAILED", e.getMessage());
        }
    }
    
    private Mail createSendGridMail(NotificationMessage message) {
        Email from = new Email(getFromAddress());
        String subject = message.getSubject();
        Email to = new Email(message.getReceiver().getValue());
        
        Content content;
        if (message.isHtmlContent()) {
            content = new Content("text/html", message.getContent());
        } else {
            content = new Content("text/plain", message.getContent());
        }
        
        Mail mail = new Mail(from, subject, to, content);
        
        // 添加个人化设置
        Personalization personalization = new Personalization();
        personalization.addTo(to);
        
        // 添加变量替换
        if (message.getVariables() != null) {
            for (Map.Entry<String, Object> entry : message.getVariables().entrySet()) {
                personalization.addSubstitution("{{" + entry.getKey() + "}}", 
                                              entry.getValue().toString());
            }
        }
        
        mail.addPersonalization(personalization);
        
        // 添加跟踪设置
        TrackingSettings trackingSettings = new TrackingSettings();
        ClickTrackingSetting clickTrackingSetting = new ClickTrackingSetting();
        clickTrackingSetting.setEnable(true);
        trackingSettings.setClickTracking(clickTrackingSetting);
        mail.setTrackingSettings(trackingSettings);
        
        return mail;
    }
}

关键实现要点：

API集成：集成第三方邮件服务API
个人化：支持邮件个人化设置
变量替换：支持模板变量替换
跟踪功能：支持邮件跟踪功能

推送通道适配器

iOS推送适配器

// 示例：iOS推送适配器（APNs）
@Component
public class IosPushAdapter implements NotificationChannel {
    
    private final ApnsClient apnsClient;
    private final ChannelConfig channelConfig;
    
    @Override
    public SendResult send(NotificationMessage message) {
        try {
            ApnsPayloadBuilder payloadBuilder = new ApnsPayloadBuilder();
            
            // 构建推送负载
            if (message.getTitle() != null) {
                payloadBuilder.setAlertTitle(message.getTitle());
            }
            
            if (message.getContent() != null) {
                payloadBuilder.setAlertBody(message.getContent());
            }
            
            // 添加自定义数据
            if (message.getExtendedProperties() != null) {
                for (Map.Entry<String, Object> entry : message.getExtendedProperties().entrySet()) {
                    payloadBuilder.addCustomProperty(entry.getKey(), entry.getValue());
                }
            }
            
            String payload = payloadBuilder.build();
            
            // 发送推送
            String deviceToken = message.getReceiver().getValue();
            SimpleApnsPushNotification pushNotification = 
                new SimpleApnsPushNotification(deviceToken, payload);
                
            CompletableFuture<PushNotificationResponse<SimpleApnsPushNotification>> sendFuture = 
                apnsClient.sendNotification(pushNotification);
                
            PushNotificationResponse<SimpleApnsPushNotification> response = sendFuture.get();
            
            if (response.isAccepted()) {
                return createSuccessResult(message.getMessageId());
            } else {
                return createFailedResult(message.getMessageId(), 
                                        response.getRejectionReason(), 
                                        response.getRejectionDescription());
            }
        } catch (Exception e) {
            log.error("发送iOS推送失败: messageId={}", message.getMessageId(), e);
            return createFailedResult(message.getMessageId(), "APNS_SEND_FAILED", e.getMessage());
        }
    }
}

关键实现要点：

负载构建：构建APNs推送负载
自定义数据：支持自定义数据传递
异步处理：使用异步方式发送推送
响应处理：处理推送响应结果

Android推送适配器

// 示例：Android推送适配器（FCM）
@Component
public class AndroidPushAdapter implements NotificationChannel {
    
    private final FirebaseMessaging firebaseMessaging;
    private final ChannelConfig channelConfig;
    
    @Override
    public SendResult send(NotificationMessage message) {
        try {
            Message fcmMessage = createFcmMessage(message);
            String response = firebaseMessaging.send(fcmMessage);
            return createSuccessResult(message.getMessageId(), response);
        } catch (Exception e) {
            log.error("发送Android推送失败: messageId={}", message.getMessageId(), e);
            return createFailedResult(message.getMessageId(), "FCM_SEND_FAILED", e.getMessage());
        }
    }
    
    private Message createFcmMessage(NotificationMessage message) {
        Notification notification = Notification.builder()
            .setTitle(message.getTitle())
            .setBody(message.getContent())
            .build();
            
        AndroidConfig androidConfig = AndroidConfig.builder()
            .setPriority(AndroidConfig.Priority.HIGH)
            .setNotification(AndroidNotification.builder()
                .setChannelId(getDefaultChannelId())
                .build())
            .build();
            
        return Message.builder()
            .setToken(message.getReceiver().getValue())
            .setNotification(notification)
            .setAndroidConfig(androidConfig)
            .putAllData(convertVariablesToData(message.getVariables()))
            .build();
    }
    
    private Map<String, String> convertVariablesToData(Map<String, Object> variables) {
        Map<String, String> data = new HashMap<>();
        if (variables != null) {
            for (Map.Entry<String, Object> entry : variables.entrySet()) {
                data.put(entry.getKey(), entry.getValue().toString());
            }
        }
        return data;
    }
}

关键实现要点：

消息构建：构建FCM推送消息
通知配置：配置Android推送通知
数据传递：支持自定义数据传递
优先级设置：设置推送优先级

适配器工厂模式

通过工厂模式管理不同类型的适配器：

适配器工厂实现

// 示例：通道适配器工厂
@Component
public class ChannelAdapterFactory {
    
    @Autowired
    private List<NotificationChannel> channels;
    
    @Autowired
    private ChannelConfigService configService;
    
    public NotificationChannel createChannel(String channelId) {
        ChannelConfig config = configService.getChannelConfig(channelId);
        if (config == null) {
            throw new ChannelNotFoundException("通道配置未找到: " + channelId);
        }
        
        switch (config.getChannelType().toLowerCase()) {
            case "sms":
                return createSmsChannel(config);
            case "email":
                return createEmailChannel(config);
            case "push":
                return createPushChannel(config);
            case "voice":
                return createVoiceChannel(config);
            case "im":
                return createImChannel(config);
            default:
                throw new UnsupportedChannelTypeException("不支持的通道类型: " + config.getChannelType());
        }
    }
    
    private NotificationChannel createSmsChannel(ChannelConfig config) {
        ProviderConfig providerConfig = config.getProviderConfig();
        String providerType = providerConfig.getCustomProperties().get("providerType").toString();
        
        switch (providerType.toLowerCase()) {
            case "domestic":
                return new DomesticSmsAdapter(new DomesticSmsService(), config);
            case "international":
                return new InternationalSmsAdapter(new InternationalSmsService(), config);
            case "twilio":
                return new TwilioSmsAdapter(new TwilioSmsService(), config);
            default:
                throw new UnsupportedProviderException("不支持的短信供应商: " + providerType);
        }
    }
    
    private NotificationChannel createEmailChannel(ChannelConfig config) {
        ProviderConfig providerConfig = config.getProviderConfig();
        String providerType = providerConfig.getCustomProperties().get("providerType").toString();
        
        switch (providerType.toLowerCase()) {
            case "smtp":
                return new SmtpEmailAdapter(createJavaMailSender(providerConfig), config);
            case "sendgrid":
                return new SendGridEmailAdapter(createSendGridClient(providerConfig), config);
            case "ses":
                return new SesEmailAdapter(createSesClient(providerConfig), config);
            default:
                throw new UnsupportedProviderException("不支持的邮件供应商: " + providerType);
        }
    }
    
    // 其他通道类型的创建方法...
}

关键工厂要点：

动态创建：根据配置动态创建适配器
类型识别：识别不同的通道和供应商类型
配置注入：将配置信息注入适配器
异常处理：处理不支持的类型异常

适配器注册管理

// 示例：适配器注册管理
@Component
public class ChannelAdapterManager {
    
    private final Map<String, NotificationChannel> channelMap = new ConcurrentHashMap<>();
    private final ChannelAdapterFactory channelAdapterFactory;
    private final ChannelConfigService configService;
    
    @PostConstruct
    public void initializeChannels() {
        List<ChannelConfig> channelConfigs = configService.getAllChannelConfigs();
        for (ChannelConfig config : channelConfigs) {
            if (config.isEnabled()) {
                try {
                    NotificationChannel channel = channelAdapterFactory.createChannel(config.getChannelId());
                    channelMap.put(config.getChannelId(), channel);
                    log.info("通道适配器初始化成功: channelId={}", config.getChannelId());
                } catch (Exception e) {
                    log.error("通道适配器初始化失败: channelId={}", config.getChannelId(), e);
                }
            }
        }
    }
    
    public NotificationChannel getChannel(String channelId) {
        return channelMap.get(channelId);
    }
    
    public void reloadChannel(String channelId) {
        ChannelConfig config = configService.getChannelConfig(channelId);
        if (config != null && config.isEnabled()) {
            try {
                NotificationChannel channel = channelAdapterFactory.createChannel(channelId);
                channelMap.put(channelId, channel);
                log.info("通道适配器重新加载成功: channelId={}", channelId);
            } catch (Exception e) {
                log.error("通道适配器重新加载失败: channelId={}", channelId, e);
                // 保持原有适配器
            }
        } else {
            channelMap.remove(channelId);
            log.info("通道适配器已移除: channelId={}", channelId);
        }
    }
    
    public List<String> getAvailableChannels() {
        return new ArrayList<>(channelMap.keySet());
    }
    
    public ChannelStatus getChannelStatus(String channelId) {
        NotificationChannel channel = channelMap.get(channelId);
        if (channel != null) {
            return channel.getChannelStatus();
        }
        return ChannelStatus.UNAVAILABLE;
    }
}