面试题：Java创建型设计模式在大型分布式系统中的优化与拓展

1. 单例模式

作用：在分布式系统中，某些资源（如数据库连接池、缓存管理器等）只需要一个实例，以避免资源浪费和不一致问题，提高性能和可维护性。
实现思路：
- 饿汉式：

public class Singleton {
    private static final Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式（线程安全）：

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查锁（DCL）：

public class Singleton {
    private volatile static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类：

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

2. 工厂模式

简单工厂模式：
- 作用：在分布式系统中，当需要创建不同类型的对象（如不同的数据处理器）时，使用简单工厂模式可以将对象的创建和使用分离，提高可维护性和可扩展性。
- 实现思路：

interface DataProcessor {
    void process();
}
class JsonDataProcessor implements DataProcessor {
    @Override
    public void process() {
        System.out.println("Processing JSON data");
    }
}
class XmlDataProcessor implements DataProcessor {
    @Override
    public void process() {
        System.out.println("Processing XML data");
    }
}
class DataProcessorFactory {
    public static DataProcessor createDataProcessor(String type) {
        if ("json".equals(type)) {
            return new JsonDataProcessor();
        } else if ("xml".equals(type)) {
            return new XmlDataProcessor();
        }
        return null;
    }
}

工厂方法模式：
- 作用：在简单工厂模式基础上，进一步解耦对象创建逻辑，使得创建对象的子类可以有不同的创建逻辑，更适合复杂的分布式系统场景，增加可扩展性。
- 实现思路：

abstract class DataProcessorFactory {
    public abstract DataProcessor createDataProcessor();
}
class JsonDataProcessorFactory extends DataProcessorFactory {
    @Override
    public DataProcessor createDataProcessor() {
        return new JsonDataProcessor();
    }
}
class XmlDataProcessorFactory extends DataProcessorFactory {
    @Override
    public DataProcessor createDataProcessor() {
        return new XmlDataProcessor();
    }
}

抽象工厂模式：
- 作用：当分布式系统中需要创建一系列相关对象时（如不同类型的数据处理器及其对应的配置管理器），抽象工厂模式提供了一种创建对象家族的方式，增强了系统的可维护性和可扩展性。
- 实现思路：

interface ConfigManager {
    void configure();
}
class JsonConfigManager implements ConfigManager {
    @Override
    public void configure() {
        System.out.println("Configuring JSON data processor");
    }
}
class XmlConfigManager implements ConfigManager {
    @Override
    public void configure() {
        System.out.println("Configuring XML data processor");
    }
}
abstract class AbstractFactory {
    public abstract DataProcessor createDataProcessor();
    public abstract ConfigManager createConfigManager();
}
class JsonFactory extends AbstractFactory {
    @Override
    public DataProcessor createDataProcessor() {
        return new JsonDataProcessor();
    }
    @Override
    public ConfigManager createConfigManager() {
        return new JsonConfigManager();
    }
}
class XmlFactory extends AbstractFactory {
    @Override
    public DataProcessor createDataProcessor() {
        return new XmlDataProcessor();
    }
    @Override
    public ConfigManager createConfigManager() {
        return new XmlConfigManager();
    }
}

3. 建造者模式

作用：在分布式系统中，当创建复杂对象（如构建复杂的消息对象用于分布式通信）时，建造者模式可以将对象的构建过程和表示分离，使得同样的构建过程可以创建不同的表示，提高可维护性和可扩展性。
实现思路：

class Message {
    private String header;
    private String body;
    private String footer;
    // getters and setters
    @Override
    public String toString() {
        return "Message{" +
                "header='" + header + '\'' +
                ", body='" + body + '\'' +
                ", footer='" + footer + '\'' +
                '}';
    }
}
interface MessageBuilder {
    void buildHeader();
    void buildBody();
    void buildFooter();
    Message getMessage();
}
class JsonMessageBuilder implements MessageBuilder {
    private Message message = new Message();
    @Override
    public void buildHeader() {
        message.setHeader("{\"type\":\"json\"}");
    }
    @Override
    public void buildBody() {
        message.setBody("{\"data\":\"some json data\"}");
    }
    @Override
    public void buildFooter() {
        message.setFooter("}");
    }
    @Override
    public Message getMessage() {
        return message;
    }
}
class MessageDirector {
    private MessageBuilder messageBuilder;
    public MessageDirector(MessageBuilder messageBuilder) {
        this.messageBuilder = messageBuilder;
    }
    public Message constructMessage() {
        messageBuilder.buildHeader();
        messageBuilder.buildBody();
        messageBuilder.buildFooter();
        return messageBuilder.getMessage();
    }
}

通过合理使用这些创建型设计模式，可以有效地对大型分布式系统进行优化和拓展，提升系统的可维护性、可扩展性以及性能。

星途面试题库

面试题：Java创建型设计模式在大型分布式系统中的优化与拓展

知识考点

面试题答案

1. 单例模式

2. 工厂模式

3. 建造者模式