正文

掌握Java分布式系统，从这5个实用设计模式案例开始学

/0 浏览量
0604

分布式系统因其可以扩展性强、可靠性高、高并发处理能力等优势，在当今互联网领域中扮演着至关重要的角色。在Java领域，设计模式是构建高效、可扩展的分布式系统的重要工具。以下是五个实用设计模式案例，它们将帮助您更好地理解如何在Java中设计和实现分布式系统。

1. 发布/订阅（Publisher/Subscriber）模式

发布/订阅模式是一种消息驱动架构，其中消息的生产者（Publisher）发送消息，而消息的消费者（Subscriber）根据订阅的主题（Topic）接收消息。

案例分析：

interface MessageListener {
    void onMessageReceived(String message);
}

public class MessageBroker {
    private final ConcurrentHashMap<String, List<MessageListener>> subscribers = new ConcurrentHashMap<>();

    public void subscribe(String topic, MessageListener listener) {
        subscribers.computeIfAbsent(topic, k -> new ArrayList<>()).add(listener);
    }

    public void publish(String topic, String message) {
        List<MessageListener> listeners = subscribers.getOrDefault(topic, Collections.emptyList());
        listeners.forEach(listener -> listener.onMessageReceived(message));
    }
}

在这个例子中，MessageBroker 作为消息的代理，它维护一个主题到订阅者的映射，使得生产者可以发送消息到特定主题，所有订阅该主题的消费者都能接收到消息。

2. 责任链（Chain of Responsibility）模式

责任链模式允许将请求在不同处理器间传递，直到有一个处理器能够处理它为止。

案例分析：

interface Handler {
    void handleRequest(String request);
}

class LoggerHandler implements Handler {
    private final Handler next;

    public LoggerHandler(Handler next) {
        this.next = next;
    }

    @Override
    public void handleRequest(String request) {
        System.out.println("Logger: " + request);
        if (next != null) {
            next.handleRequest(request);
        }
    }
}

class ServerHandler implements Handler {
    @Override
    public void handleRequest(String request) {
        System.out.println("Server: " + request);
    }
}

// Usage
Handler chain = new LoggerHandler(new LoggerHandler(new ServerHandler()));
chain.handleRequest("Handle this request");

在这个例子中，每个处理器Handler都有一个next引用，用于传递未被处理的请求到下一个处理器。这可以用于日志记录、授权检查、业务处理等多个层次。

3. 状态机（State Machine）模式

状态机模式用于在有限的状态转换之间管理对象，常用于实现复杂业务流程，如工作流或事务。

案例分析：

public class WorkflowContext {
    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public void changeState(String newState) {
        state = state.apply(this, newState);
    }

    public String getCurrentState() {
        return state.getName();
    }
}

enum State {
    OPEN, IN_PROGRESS, COMPLETED, CANCELED;

    public State apply(WorkflowContext context, String newState) {
        // 实现状态转换逻辑
        if (newState.equals("IN_PROGRESS") && this == OPEN) {
            return IN_PROGRESS;
        }
        // 更多状态转换
        return this;
    }
}

WorkflowContext 类通过调用不同的apply方法来改变其状态。这可以扩展以处理复杂的业务逻辑。

4. 缓存（Cache）模式

缓存模式用于提高分布式系统中数据访问速度，减少数据库的访问频率。

案例分析：

class LRUCache<K, V> {
    private final Map<K, V> cache = new LinkedHashMap<>();
    private final int capacity;

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }

    public V get(K key) {
        V value = cache.get(key);
        if (value == null) {
            put(key, value); // 假设有一个从数据库加载值的方法
        }
        return value;
    }

    public void put(K key, V value) {
        cache.put(key, value);
        if (cache.size() > capacity) {
            cache.remove(cache.keySet().iterator().next()); // 移除最久未使用项
        }
    }
}

LRUCache 是一个简单的最少最近使用（LRU）缓存实现，它基于LinkedHashMap来保持键值对的顺序。

5. 服务发现（Service Discovery）模式

服务发现模式用于动态定位和访问服务，尤其是在大型分布式系统中。

案例分析：

class ServiceDiscovery {
    private final ConcurrentHashMap<String, List<String>> services = new ConcurrentHashMap<>();

    public void registerService(String serviceName, String instanceId) {
        services.computeIfAbsent(serviceName, k -> new ArrayList<>()).add(instanceId);
    }

    public List<String> findInstances(String serviceName) {
        return services.getOrDefault(serviceName, Collections.emptyList());
    }
}

ServiceDiscovery 类提供了一个简单的服务注册和发现机制，允许客户端查询特定服务的所有实例。

通过这些案例，您可以在Java中应用这些设计模式，从而构建更加高效和灵活的分布式系统。实践是掌握这些模式的最佳方式，希望这些建模例能为您提供灵感。

-- 展开阅读全文 --