首页手记 Java分布式学习入门指南

Java分布式学习入门指南

标签：

Java Spring Cloud

概述

本文详细介绍了Java分布式系统的各个方面，包括分布式系统概述、Java在分布式系统中的应用、分布式架构模式、服务发现与注册、负载均衡与路由、以及分布式缓存机制。文章还通过实战案例展示了如何使用Spring Boot和Docker搭建分布式应用，并深入探讨了分布式数据存储和ZooKeeper的使用方法。通过这些内容，读者可以全面了解和掌握Java分布式学习的相关知识。

Java分布式系统简介

分布式系统概述

分布式系统是一种系统，它包含多个通过网络互连的独立计算机或节点，它们能够协同工作以实现特定目标。这些节点之间通过网络进行通信，以完成单个节点无法完成的任务。分布式系统的关键特点是，它们能够提供比单一系统更高的性能和可用性。通过将任务分配到多个节点，分布式系统可以在多个方面提供优势，例如负载均衡、容错和扩展性。

Java在分布式系统中的应用

Java语言因其平台独立性、强大的类库和丰富的开发工具，在分布式系统中得到了广泛应用。Java提供了多种机制来支持分布式应用的开发，例如Java RMI（远程方法调用）、Socket编程、Java NIO（非阻塞I/O）和Java EE（企业版）等。这些技术使得Java成为开发分布式应用的理想选择。

Java RMI示例

Java RMI允许远程对象之间进行分布式通信。以下是一个简单的RMI示例，展示了如何定义、实现和注册远程对象，以及如何通过客户端调用远程方法。

定义远程接口：

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface HelloWorld extends Remote {
    String sayHello() throws RemoteException;
}

实现远程接口：

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class HelloWorldImpl extends UnicastRemoteObject implements HelloWorld {
    protected HelloWorldImpl() throws RemoteException {
        super();
    }

    @Override
    public String sayHello() throws RemoteException {
        return "Hello, world!";
    }
}

注册远程对象：

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class HelloWorldServer {
    public static void main(String[] args) {
        try {
            HelloWorldImpl hw = new HelloWorldImpl();
            Registry registry = LocateRegistry.createRegistry(1099);
            registry.rebind("HelloWorld", hw);
            System.out.println("Server ready.");
        } catch (Exception e) {
            System.err.println("Server exception: " + e.toString());
            e.printStackTrace();
        }
    }
}

调用远程方法：

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class HelloWorldClient {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.getRegistry("localhost", 1099);
            HelloWorld hw = (HelloWorld) registry.lookup("HelloWorld");
            System.out.println(hw.sayHello());
        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
        }
    }
}

分布式系统的优点与挑战

优点

高可用性：分布式系统可以提供比单一系统更高的可用性，因为即使某个节点出现故障，其他节点仍能继续提供服务。
可伸缩性：通过增加更多的节点，可以轻松地扩展分布式系统以处理更多负载。
负载均衡：分布式系统可以将任务分配给多个节点，从而实现负载均衡，避免单个节点过载。
容错性：分布式系统可以设计为具有容错性，能够在节点故障时仍然提供服务。
灵活性：分布式系统可以根据需求动态添加或移除节点，提高了系统的灵活性。

挑战

复杂性：分布式系统的设计和实现比单一系统更复杂，需要处理网络延迟、节点故障和数据一致性等问题。
数据一致性：在分布式系统中保持数据一致性是一个挑战，特别是在节点之间可能存在网络延迟或故障的情况下。
安全性和隐私：分布式系统需要保护节点之间的通信安全，并确保数据的隐私。
部署和维护：分布式系统的部署和维护比单一系统更为复杂，需要考虑节点的部署位置、网络配置和数据备份等问题。

分布式开发基础

Java网络编程基础

Java网络编程是开发分布式应用的基础。Java提供了多种网络编程技术，包括传统的Socket编程和基于NIO的异步编程。下面我们将介绍Java网络编程的基础知识和示例代码。

Socket编程示例

Socket编程是Java网络编程的基础。以下是一个简单的Socket编程示例，演示了如何创建一个服务器端和一个客户端。

创建服务器端：

import java.io.*;
import java.net.*;

public class SimpleServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8000);
        System.out.println("Server started, waiting for connection...");

        Socket clientSocket = serverSocket.accept();
        System.out.println("Client connected.");

        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            System.out.println("Received: " + inputLine);
            out.println("Echo: " + inputLine);
        }

        clientSocket.close();
        serverSocket.close();
    }
}

创建客户端：

import java.io.*;
import java.net.*;

public class SimpleClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8000);
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        out.println("Hello, server!");
        String response = in.readLine();
        System.out.println("Received: " + response);

        socket.close();
    }
}

Java NIO示例

Java NIO（New I/O）是Java提供的一种异步编程模型，适用于高并发场景。以下是一个简单的NIO示例，展示了如何使用NIO实现一个简单的服务器端。

创建NIO服务器端：

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;

public class SimpleNioServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.socket().bind(new InetSocketAddress(8001));

        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            selector.select();
            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (key.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead;
                    while ((bytesRead = socketChannel.read(buffer)) > 0) {
                        buffer.flip();
                        System.out.println("Received: " + new String(buffer.array(), 0, bytesRead));
                        buffer.clear();
                    }
                    socketChannel.close();
                }
            }
        }
    }
}

Java并发编程基础

Java并发编程是开发分布式应用中另一个重要的方面。Java提供了多种并发机制，包括线程、锁、并发容器和并发工具类。以下我们将介绍Java并发编程的基础知识和示例代码。

创建和管理线程

Java提供了多种方式来创建和管理线程。以下是一个简单的线程示例，演示了如何创建并启动一个线程。

创建线程示例：

public class SimpleThread extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + getName() + " - " + i);
        }
    }

    public static void main(String[] args) {
        SimpleThread thread = new SimpleThread();
        thread.start();
    }
}

使用锁控制并发访问

Java提供了多种锁机制来控制并发访问，确保多个线程能够安全地访问共享资源。以下是一个简单的锁示例，演示了如何使用synchronized关键字来控制并发访问。

使用锁示例：

public class SimpleLock {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }

    public static void main(String[] args) {
        SimpleLock lock = new SimpleLock();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                lock.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                lock.increment();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + lock.getCount());
    }
}

并发容器和并发工具类

Java提供了多种并发容器和并发工具类来简化并发编程。以下是一个简单的并发容器示例，演示了如何使用ConcurrentHashMap来实现线程安全的映射。

使用并发容器示例：

import java.util.concurrent.*;

public class SimpleConcurrentMap {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.put("Key" + i, i);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.put("Key" + i, i);
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Map size: " + map.size());
    }
}

分布式架构模式

服务发现与注册

服务发现与注册是分布式系统中的一种常见模式，用于解决服务发现和负载均衡等问题。服务发现是指客户端能够自动找到并连接到可用的服务实例；服务注册则是服务实例向服务注册中心注册自己的信息，以便其他服务能够找到它。

服务注册与发现示例

以下是一个简单的服务注册与发现示例，使用了ZooKeeper作为服务注册中心。

创建服务注册中心（ZooKeeper）：

docker run -d --name zookeeper -p 2181:2181 -p 2888:2888 -p 3888:3888 zookeeper

服务注册示例：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class SimpleServiceRegistry {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICE_PATH = "/services";
    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getType() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });

        latch.await();

        String serviceId = zk.create(SERVICE_PATH, "service1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        System.out.println("Service registered: " + serviceId);

        zk.close();
    }
}

服务发现示例：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.util.List;
import java.util.concurrent.CountDownLatch;

public class SimpleServiceDiscovery {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICE_PATH = "/services";
    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getType() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });

        latch.await();

        List<String> serviceIds = zk.getChildren(SERVICE_PATH, true);

        for (String serviceId : serviceIds) {
            byte[] data = zk.getData(SERVICE_PATH + "/" + serviceId, false, new Stat());
            System.out.println("Service found: " + new String(data));
        }

        zk.close();
    }
}

负载均衡与路由

负载均衡和路由是分布式系统中常见的模式，用于将请求分发到多个服务实例上。负载均衡可以使用多种算法实现，例如轮询、随机和最少连接等。

负载均衡示例

以下是一个简单的负载均衡示例，展示了如何使用轮询算法来实现负载均衡。

创建负载均衡器：

import java.util.*;

public class SimpleLoadBalancer {
    private List<String> serviceIds = new ArrayList<>();
    private Random random = new Random();

    public void addService(String serviceId) {
        serviceIds.add(serviceId);
    }

    public String getLoadBalancedService() {
        return serviceIds.get(random.nextInt(serviceIds.size()));
    }

    public static void main(String[] args) {
        SimpleLoadBalancer lb = new SimpleLoadBalancer();
        lb.addService("service1");
        lb.addService("service2");
        lb.addService("service3");

        for (int i = 0; i < 10; i++) {
            String service = lb.getLoadBalancedService();
            System.out.println("Load balanced service: " + service);
        }
    }
}

分布式缓存机制

分布式缓存机制是分布式系统中常见的模式，用于存储和检索频繁访问的数据，以提高系统的性能和响应速度。常见的分布式缓存系统有Redis、Memcached等。

通过Redis实现分布式缓存示例

以下是一个简单的Redis分布式缓存示例，展示了如何使用Redis客户端库Jedis来实现分布式缓存。

创建Redis客户端示例：

import redis.clients.jedis.*;

public class SimpleRedisCache {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");

        // 设置缓存值
        jedis.set("key", "value");

        // 获取缓存值
        String value = jedis.get("key");
        System.out.println("Cached value: " + value);

        // 删除缓存值
        jedis.del("key");

        jedis.close();
    }
}

使用Memcached实现分布式缓存示例

以下是一个简单的Memcached分布式缓存示例，展示了如何使用Memcached客户端库spymemcached来实现分布式缓存。

创建Memcached客户端示例：

import net.spy.memcached.*;

public class SimpleMemcachedCache {
    private static final String MEMCACHED_SERVER = "localhost";
    private static final int MEMCACHED_PORT = 11211;

    public static void main(String[] args) {
        MemcachedClient memcachedClient = new MemcachedClient(new InetSocketAddress(MEMCACHED_SERVER, MEMCACHED_PORT));

        // 设置缓存值
        memcachedClient.set("key", 0, "value");

        // 获取缓存值
        String value = memcachedClient.get("key").toString();
        System.out.println("Cached value: " + value);

        // 删除缓存值
        memcachedClient.delete("key");

        memcachedClient.shutdown();
    }
}

实战案例：实现一个简单的分布式应用

设计一个分布式应用

设计一个简单的分布式应用需要考虑以下几个方面：服务的定义、服务的部署和调用、服务的发现与注册、负载均衡与路由。

服务定义

服务定义是指定义服务接口和实现。以下是一个简单的服务接口和实现示例。

服务接口：

public interface SimpleService {
    String sayHello(String name);
}

服务实现：

public class SimpleServiceImpl implements SimpleService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

服务部署和调用

服务部署是指将服务部署到多个节点上，服务调用是指客户端如何调用服务。以下是一个简单的服务部署和调用示例。

服务注册：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class SimpleServiceRegistry {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICE_PATH = "/services";
    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getType() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });

        latch.await();

        String serviceId = zk.create(SERVICE_PATH, "service1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        System.out.println("Service registered: " + serviceId);

        zk.close();
    }
}

服务发现与调用：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.util.List;
import java.util.concurrent.CountDownLatch;

public class SimpleServiceDiscovery {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICE_PATH = "/services";
    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getType() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });

        latch.await();

        List<String> serviceIds = zk.getChildren(SERVICE_PATH, true);

        for (String serviceId : serviceIds) {
            byte[] data = zk.getData(SERVICE_PATH + "/" + serviceId, false, new Stat());
            String serviceAddress = new String(data);
            SimpleService service = new SimpleServiceStub(serviceAddress);
            String result = service.sayHello("world");
            System.out.println(result);
        }

        zk.close();
    }

    public static class SimpleServiceStub implements SimpleService {
        private final String serviceAddress;

        public SimpleServiceStub(String serviceAddress) {
            this.serviceAddress = serviceAddress;
        }

        @Override
        public String sayHello(String name) {
            // 实现服务调用逻辑
            return "Hello, " + name + "!";
        }
    }
}

使用Spring Boot搭建服务

Spring Boot是一个基于Spring框架的快速开发工具，可以轻松地创建独立的、生产级别的Spring应用。以下是一个简单的Spring Boot服务示例，展示了如何使用Spring Boot搭建服务。

创建Spring Boot服务：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SimpleSpringBootService {
    public static void main(String[] args) {
        SpringApplication.run(SimpleSpringBootService.class, args);
    }

    @GetMapping("/hello")
    public String sayHello(@RequestParam String name) {
        return "Hello, " + name + "!";
    }
}

创建Spring Boot客户端：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class SimpleSpringBootClient {
    public static void main(String[] args) {
        SpringApplication.run(SimpleSpringBootClient.class, args);

        RestTemplate restTemplate = new RestTemplate();
        String result = restTemplate.getForObject("http://localhost:8080/hello?name=world", String.class);
        System.out.println(result);
    }
}

服务的部署与测试

服务部署是指将服务部署到多个节点上。以下是一个简单的服务部署示例，展示了如何使用Docker和Kubernetes部署服务。

创建Docker镜像：

FROM openjdk:11-jre-slim
COPY target/simple-spring-boot-service.jar /app/simple-spring-boot-service.jar
ENTRYPOINT ["java", "-jar", "/app/simple-spring-boot-service.jar"]

构建Docker镜像：

docker build -t simple-spring-boot-service .

运行Docker容器：

docker run -d -p 8080:8080 --name simple-spring-boot-service simple-spring-boot-service

使用Kubernetes部署服务：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-spring-boot-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: simple-spring-boot-service
  template:
    metadata:
      labels:
        app: simple-spring-boot-service
    spec:
      containers:
      - name: simple-spring-boot-service
        image: simple-spring-boot-service:latest
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: simple-spring-boot-service
spec:
  selector:
    app: simple-spring-boot-service
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  type: LoadBalancer

部署Kubernetes资源：

kubectl apply -f simple-spring-boot-service-deployment.yaml

测试服务：

kubectl get services
kubectl get pods
curl http://<service-ip>:8080/hello?name=world

分布式数据存储

基础数据存储技术介绍

分布式数据存储技术有多种实现，例如关系型数据库、NoSQL数据库和分布式文件系统。以下我们将介绍几种常见的分布式数据存储技术。

关系型数据库

关系型数据库是一种基于表格的数据存储系统，支持事务处理和ACID特性。常见的关系型数据库有MySQL、PostgreSQL、Oracle等。

NoSQL数据库

NoSQL数据库是一种非关系型的数据存储系统，支持高并发和高可用性。常见的NoSQL数据库有MongoDB、Cassandra、Redis等。

分布式文件系统

分布式文件系统是一种跨多个节点的文件存储系统，支持高可用性和高可靠性。常见的分布式文件系统有HDFS、GlusterFS等。

使用Redis实现分布式缓存

Redis是一个开源的内存数据存储系统，支持多种数据结构和丰富的操作。以下是一个简单的Redis分布式缓存示例，展示了如何使用Redis客户端库Jedis来实现分布式缓存。

创建Redis客户端示例：

import redis.clients.jedis.*;

public class SimpleRedisCache {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");

        // 设置缓存值
        jedis.set("key", "value");

        // 获取缓存值
        String value = jedis.get("key");
        System.out.println("Cached value: " + value);

        // 删除缓存值
        jedis.del("key");

        jedis.close();
    }
}

使用MySQL与分布式数据库

MySQL是一种常见的关系型数据库，支持ACID事务和多种存储引擎。以下是一个简单的MySQL分布式数据库示例，展示了如何使用Java连接MySQL数据库并执行SQL查询。

创建数据库连接示例：

import java.sql.*;

public class SimpleMySqlDatabase {
    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        Statement stmt = null;

        try {
            String url = "jdbc:mysql://localhost:3306/mydb";
            String user = "root";
            String password = "password";

            conn = DriverManager.getConnection(url, user, password);
            stmt = conn.createStatement();

            String sql = "SELECT * FROM users";
            ResultSet rs = stmt.executeQuery(sql);

            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } finally {
            if (stmt != null) stmt.close();
            if (conn != null) conn.close();
        }
    }
}

分布式协调服务

ZooKeeper简介

ZooKeeper是一种开源的分布式协调服务，提供配置管理、命名和分布式同步等功能。ZooKeeper使用类似于文件系统的数据模型，支持多种操作，如创建、删除和更新节点。

ZooKeeper数据模型

ZooKeeper的数据模型类似于文件系统，支持多级目录结构和节点属性。每个节点可以包含数据和子节点，支持多种操作，如创建、删除和更新节点。

ZooKeeper主要特性

一致性：ZooKeeper保证所有客户端能够看到一致的数据视图。
原子性：ZooKeeper保证所有操作要么全部成功，要么全部失败。
可靠性：ZooKeeper保证所有操作能够可靠地执行。
持久性：ZooKeeper支持持久节点，节点数据能够持久化存储。
临时性：ZooKeeper支持临时节点，节点数据在会话结束时自动删除。

使用ZooKeeper实现服务发现

以下是一个简单的服务发现示例，展示了如何使用ZooKeeper实现服务发现。

创建服务注册中心（ZooKeeper）：

docker run -d --name zookeeper -p 2181:2181 -p 2888:2888 -p 3888:3888 zookeeper

服务注册示例：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class SimpleServiceRegistry {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICE_PATH = "/services";
    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getType() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });

        latch.await();

        String serviceId = zk.create(SERVICE_PATH, "service1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        System.out.println("Service registered: " + serviceId);

        zk.close();
    }
}

服务发现示例：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.util.List;
import java.util.concurrent.CountDownLatch;

public class SimpleServiceDiscovery {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICE_PATH = "/services";
    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getType() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });

        latch.await();

        List<String> serviceIds = zk.getChildren(SERVICE_PATH, true);

        for (String serviceId : serviceIds) {
            byte[] data = zk.getData(SERVICE_PATH + "/" + serviceId, false, new Stat());
            String serviceAddress = new String(data);
            SimpleService service = new SimpleServiceStub(serviceAddress);
            String result = service.sayHello("world");
            System.out.println(result);
        }

        zk.close();
    }

    public static class SimpleServiceStub implements SimpleService {
        private final String serviceAddress;

        public SimpleServiceStub(String serviceAddress) {
            this.serviceAddress = serviceAddress;
        }

        @Override
        public String sayHello(String name) {
            // 实现服务调用逻辑
            return "Hello, " + name + "!";
        }
    }
}

使用ZooKeeper实现分布式锁

以下是一个简单的分布式锁示例，展示了如何使用ZooKeeper实现分布式锁。

创建分布式锁示例：

import org.apache.zookeeper.*;
import org.apache.zookeeper.client.ZooKeeperClient;

import java.util.concurrent.CountDownLatch;

public class SimpleDistributedLock {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String LOCK_PATH = "/lock";

    public class DistributedLock implements Watcher {
        private ZooKeeper zk;
        private String lockId;
        private CountDownLatch latched = new CountDownLatch(1);

        public DistributedLock(String lockId) throws IOException, InterruptedException {
            zk = new ZooKeeper(ZK_ADDRESS, 3000, this);
            this.lockId = lockId;
            zk.create(LOCK_PATH, lockId.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            latched.await();
        }

        @Override
        public void process(WatchedEvent event) {
            if (event.getType() == Watcher.Event.EventType.NodeCreated) {
                latched.countDown();
            }
        }

        public void lock() throws InterruptedException {
            while (true) {
                List<String> lockIds = zk.getChildren(LOCK_PATH, false);
                if (lockIds.contains(lockId)) {
                    return;
                }
                zk.create(LOCK_PATH + "/" + lockId, lockId.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                synchronized (lockIds) {
                    if (lockIds.contains(lockId)) {
                        return;
                    }
                }
            }
        }

        public void unlock() {
            zk.delete(LOCK_PATH + "/" + lockId, -1);
        }

        public void close() throws InterruptedException {
            zk.close();
        }

        public static void main(String[] args) throws IOException, InterruptedException {
            DistributedLock lock1 = new DistributedLock("lock1");
            DistributedLock lock2 = new DistributedLock("lock2");

            lock1.lock();
            System.out.println("Lock1 acquired");

            lock2.lock();
            System.out.println("Lock2 acquired");

            lock1.unlock();
            System.out.println("Lock1 released");

            lock2.unlock();
            System.out.println("Lock2 released");
        }
    }
}

以上是Java分布式学习入门指南的详细内容，涵盖了Java分布式系统的各个方面，包括基础概念、开发基础、架构模式、实战案例、数据存储和协调服务。希望对你有所帮助。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

繁星点点滴滴

手记
篇

粉丝

67

获赞与收藏

333

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340925 3155

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java分布式学习入门指南

分布式系统概述

Java在分布式系统中的应用

Java RMI示例

分布式系统的优点与挑战

优点

挑战

Java网络编程基础

Socket编程示例

Java NIO示例

Java并发编程基础

创建和管理线程

使用锁控制并发访问

并发容器和并发工具类

服务发现与注册

服务注册与发现示例

负载均衡与路由

负载均衡示例

分布式缓存机制

通过Redis实现分布式缓存示例

使用Memcached实现分布式缓存示例

设计一个分布式应用

服务定义

服务部署和调用

使用Spring Boot搭建服务

服务的部署与测试

基础数据存储技术介绍

关系型数据库

NoSQL数据库

分布式文件系统

使用Redis实现分布式缓存

使用MySQL与分布式数据库

ZooKeeper简介

ZooKeeper数据模型

ZooKeeper主要特性

使用ZooKeeper实现服务发现

使用ZooKeeper实现分布式锁

阅读免费教程