Java | 基于 ThreadLocal 实现多客户端访问设备的 REST 请求下发

关注：CodingTechWork

引言

在分布式系统中，常常会遇到多个客户端同时访问同一个机器设备的情况。为了确保每个客户端的请求都能正确地发送到目标设备，并且能够根据当前线程自动获取对应的设备信息进行操作，我们可以利用 ThreadLocal 来实现线程隔离和上下文管理。本文将详细介绍如何使用 ThreadLocal 来实现这一功能，并结合 RestTemplate 完成对设备的 REST 请求下发。

ThreadLocal 简介

ThreadLocal 是 Java 提供的一种线程局部变量存储机制。它为每个线程提供了一个独立的变量副本，使得每个线程都可以独立地访问和修改自己的变量副本，而不会相互干扰。这种机制非常适合处理多线程环境下的上下文信息传递问题。

需求分析

假设我们有一个系统，多个客户端通过不同的 IP 和端口访问同一个机器设备。我们需要在每个线程中自动获取当前客户端对应的设备信息（IP 和端口），并使用 RestTemplate 向设备发送 REST 请求。具体需求如下：

• 多客户端访问：支持多个客户端同时访问同一个设备。
• 线程隔离：每个线程只能访问当前线程的设备信息。
• 自动获取设备信息：在每个线程中自动获取当前线程的设备信息。
• REST 请求下发：使用 RestTemplate 向设备发送 REST 请求。

实现思路

1. 定义设备信息类：创建一个 Device 类，用于存储设备的 IP 和端口信息。
2. 使用 ThreadLocal 存储设备信息：创建一个 DeviceContextHolder 类，使用 ThreadLocal 来存储当前线程的设备信息。
3. REST 请求下发：创建一个 DeviceService 类，使用 RestTemplate 向设备发送 REST 请求。
4. 测试：编写测试代码，模拟多个客户端访问设备的场景。

代码实现

定义设备信息类

创建一个 Device 类，用于存储设备的 IP 和端口信息。

public class Device {
    private String ip;
    private int port;

    public Device(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public String getIp() {
        return ip;
    }

    public int getPort() {
        return port;
    }

    @Override
    public String toString() {
        return "Device{" +
                "ip='" + ip + '\'' +
                ", port=" + port +
                '}';
    }
}

使用 ThreadLocal 存储设备信息

创建一个 DeviceContextHolder 类，使用 ThreadLocal 来存储当前线程的设备信息。

import java.util.Optional;

public class DeviceContextHolder {
    private static final ThreadLocal<Device> DEVICE_THREAD_LOCAL = new ThreadLocal<>();

    public static void setDevice(Device device) {
        DEVICE_THREAD_LOCAL.set(device);
    }

    public static Optional<Device> getDevice() {
        return Optional.ofNullable(DEVICE_THREAD_LOCAL.get());
    }

    public static void clear() {
        DEVICE_THREAD_LOCAL.remove();
    }
}

3. REST 请求下发 创建一个 DeviceService 类，使用 RestTemplate 向设备发送 REST 请求。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class DeviceService {
    @Autowired
    private RestTemplate restTemplate;

    public void sendRequestToDevice() {
        Optional<Device> deviceOptional = DeviceContextHolder.getDevice();
        if (deviceOptional.isPresent()) {
            Device device = deviceOptional.get();
            String url = "http://" + device.getIp() + ":" + device.getPort() + "/api";
            System.out.println("Sending request to: " + url);
            restTemplate.getForObject(url, String.class);
        } else {
            System.out.println("No device information found in the current thread.");
        }
    }
}

测试代码

编写测试代码，模拟多个客户端访问设备的场景。

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@SpringBootApplication
public class DeviceRequestApplication {
    @Autowired
    private DeviceService deviceService;

    public static void main(String[] args) {
        SpringApplication.run(DeviceRequestApplication.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner() {
        return args -> {
            ExecutorService executorService = Executors.newFixedThreadPool(5);

            // 模拟多个客户端访问设备
            executorService.submit(() -> {
                DeviceContextHolder.setDevice(new Device("192.168.1.1", 8080));
                deviceService.sendRequestToDevice();
                DeviceContextHolder.clear();
            });

            executorService.submit(() -> {
                DeviceContextHolder.setDevice(new Device("192.168.1.2", 8081));
                deviceService.sendRequestToDevice();
                DeviceContextHolder.clear();
            });

            executorService.shutdown();
        };
    }

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

运行结果

运行测试代码后，观察控制台输出：

Sending request to: http://192.168.1.1:8080/api
Sending request to: http://192.168.1.2:8081/api

从结果可以看出，每个线程都成功地获取了当前线程的设备信息，并向对应的设备发送了 REST 请求。

总结

本文介绍了如何使用 ThreadLocal 实现多客户端访问设备的 REST 请求下发。通过 ThreadLocal，我们可以在每个线程中独立地存储和访问设备信息，确保线程隔离和上下文管理的正确性。结合 RestTemplate，我们可以轻松地向设备发送 REST 请求，实现分布式环境下的设备访问功能。在实际项目中，可以根据需求对代码进行扩展和优化，例如支持更复杂的设备信息管理、增加错误处理机制等。