基于 Abstract Factory 模式与 Singleton 模式实现一个简单的邮件生成程序，其主要 需求如下： （1） 所有的商家都对自己的客户进行了分类； （2） 所有商家都不定期地要向客户发送客户感兴趣的商品广告； （3） 所有商家都要在节假日向客户发送祝福邮件； （4） 设计的程序中应存在单例对象。用java实现

首先，我们需要定义抽象工厂接口：

// 邮件工厂接口
public interface MailFactory {
    // 创建推广邮件
    PromotionMail createPromotionMail(String userEmail);

    // 创建节日祝福邮件
    FestivalMail createFestivalMail(String userEmail);
}

接下来，我们需要实现该接口的两个具体工厂：商家A和商家B。

商家A邮件工厂的实现：

// 商家A的邮件工厂实现
public class MailFactoryA implements MailFactory {
    private static MailFactoryA instance = null;

    // 私有的构造方法
    private MailFactoryA() {}

    // 获取单例对象
    public static synchronized MailFactoryA getInstance() {
        if (instance == null) {
            instance = new MailFactoryA();
        }
        return instance;
    }

    // 创建推广邮件
    @Override
    public PromotionMail createPromotionMail(String userEmail) {
        List<String> products = new ArrayList<>();
        products.add("Product A");
        products.add("Product B");
        products.add("Product C");
        return new PromotionMail("商家A", userEmail, products);
    }

    // 创建节日祝福邮件
    @Override
    public FestivalMail createFestivalMail(String userEmail) {
        return new FestivalMail("商家A", userEmail, "春节快乐！");
    }
}

商家B邮件工厂的实现：

// 商家B的邮件工厂实现
public class MailFactoryB implements MailFactory {
    private static MailFactoryB instance = null;

    // 私有的构造方法
    private MailFactoryB() {}

    // 获取单例对象
    public static synchronized MailFactoryB getInstance() {
        if (instance == null) {
            instance = new MailFactoryB();
        }
        return instance;
    }

    // 创建推广邮件
    @Override
    public PromotionMail createPromotionMail(String userEmail) {
        List<String> products = new ArrayList<>();
        products.add("Product X");
        products.add("Product Y");
        products.add("Product Z");
        return new PromotionMail("商家B", userEmail, products);
    }

    // 创建节日祝福邮件
    @Override
    public FestivalMail createFestivalMail(String userEmail) {
        return new FestivalMail("商家B", userEmail, "新年快乐！");
    }
}

接下来，我们需要定义邮件类：

推广邮件类：

// 推广邮件类
public class PromotionMail {
    private final String sender;
    private final String receiver;
    private final List<String> products;

    public PromotionMail(String sender, String receiver, List<String> products) {
        this.sender = sender;
        this.receiver = receiver;
        this.products = products;
    }

    public String getSender() {
        return sender;
    }

    public String getReceiver() {
        return receiver;
    }

    public List<String> getProducts() {
        return products;
    }

    @Override
    public String toString() {
        return "推广邮件 [商家：" + sender + ", 接收者：" + receiver + ", 商品列表：" + products + "]";
    }
}

节日祝福邮件类：

// 节日祝福邮件类
public class FestivalMail {
    private final String sender;
    private final String receiver;
    private final String content;

    public FestivalMail(String sender, String receiver, String content) {
        this.sender = sender;
        this.receiver = receiver;
        this.content = content;
    }

    public String getSender() {
        return sender;
    }

    public String getReceiver() {
        return receiver;
    }

    public String getContent() {
        return content;
    }

    @Override
    public String toString() {
        return "节日祝福邮件 [商家：" + sender + ", 接收者：" + receiver + ", 祝福内容：" + content + "]";
    }
}

最后，我们定义一个邮件发送类，在该类中使用单例模式获取邮件工厂的实例，然后使用抽象工厂接口创建邮件。

邮件发送类：

// 邮件发送类
public class MailSender {
    // 邮件工厂
    private MailFactory mailFactory;

    // 获取单例对象
    private static MailSender instance = null;

    private MailSender(MailFactory mailFactory) {
        this.mailFactory = mailFactory;
    }

    public static synchronized MailSender getInstance(String mailFactoryName) {
        if (instance == null) {
            switch (mailFactoryName) {
                case "商家A":
                    instance = new MailSender(MailFactoryA.getInstance());
                    break;
                case "商家B":
                    instance = new MailSender(MailFactoryB.getInstance());
                    break;
                default:
                    throw new IllegalArgumentException("没有找到对应的邮件工厂");
            }
        }
        return instance;
    }

    // 发送推广邮件
    public PromotionMail sendPromotionMail(String userEmail) {
        return mailFactory.createPromotionMail(userEmail);
    }

    // 发送节日祝福邮件
    public FestivalMail sendFestivalMail(String userEmail) {
        return mailFactory.createFestivalMail(userEmail);
    }
}

使用示例：

// 发送商家A的推广邮件和节日祝福邮件
MailSender mailSenderA = MailSender.getInstance("商家A");
PromotionMail promotionMailA = mailSenderA.sendPromotionMail("customerA@example.com");
FestivalMail festivalMailA = mailSenderA.sendFestivalMail("customerA@example.com");
System.out.println(promotionMailA);
System.out.println(festivalMailA);

// 发送商家B的推广邮件和节日祝福邮件
MailSender mailSenderB = MailSender.getInstance("商家B");
PromotionMail promotionMailB = mailSenderB.sendPromotionMail("customerB@example.com");
FestivalMail festivalMailB = mailSenderB.sendFestivalMail("customerB@example.com");
System.out.println(promotionMailB);
System.out.println(festivalMailB);

输出结果：

推广邮件 [商家：商家A, 接收者：customerA@example.com, 商品列表：[Product A, Product B, Product C]]
节日祝福邮件 [商家：商家A, 接收者：customerA@example.com, 祝福内容：春节快乐！]
推广邮件 [商家：商家B, 接收者：customerB@example.com, 商品列表：[Product X, Product Y, Product Z]]
节日祝福邮件 [商家：商家B, 接收者：customerB@example.com, 祝福内容：新年快乐！]

可以看到，我们使用了抽象工厂模式和单例模式来实现该程序，使得每个商家都拥有自己的邮件工厂，并且整个程序只存在一个邮件发送对象，符合单例模式的设计要求。