Java 如何模拟在Zookepr中获取锁的void方法，我们还可以验证锁

我必须为一个方法创建一个单元测试用例，该方法使用zookeeper获取锁，并使用CompletableFuture处理数据

以下是高级代码：

import lombok.Data;
@Data
public class ConfigurationsIntegrationModel {
  public enum InteractionType {
    TEST,
    DEV;
  }
  private InteractionType interactionType;
  private String lockName;
}

import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;

@Service("configurationsIntegrationService")
public interface ConfigurationsIntegrationService {
    public default List<ConfigurationsIntegrationModel> getRecords(ConfigurationsIntegrationModel.InteractionType integrationType) {
        return Arrays.asList(getDynamicIntegrationConfigurationMock(integrationType));
    }
    private static ConfigurationsIntegrationModel getDynamicIntegrationConfigurationMock(ConfigurationsIntegrationModel.InteractionType integrationType) {
        ConfigurationsIntegrationModel configurationsIntegration = new ConfigurationsIntegrationModel();
        configurationsIntegration.setLockName("Test_Lock");
        configurationsIntegration.setInteractionType(integrationType);
        return configurationsIntegration;
    }
}

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessSemaphoreMutex;
import org.apache.curator.retry.RetryNTimes;
import java.util.concurrent.TimeUnit;
public class DistributedLockProcessor {
    private CuratorFramework client;
    private String path;
    public DistributedLockProcessor(String host, String path) {
        RetryPolicy retryPolicy = new RetryNTimes(5, 90);
        client = CuratorFrameworkFactory.newClient(host, retryPolicy);
        client.start();
    }
    public InterProcessLock acquire(String lockName) throws Exception {
        InterProcessSemaphoreMutex sharedLock = new InterProcessSemaphoreMutex(client, path + "/" + lockName);
        if (!sharedLock.acquire(0, TimeUnit.SECONDS)) {
            return null;
        }
        return sharedLock;
    }
    public boolean release(InterProcessLock sharedLock) throws Exception {
        sharedLock.release();
        return true;
    }
}

import org.apache.curator.framework.recipes.locks.InterProcessLock;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.function.Consumer;
public class LockingExecutorProcessor<T> {
    private Executor executor = null;
    private DistributedLockProcessor distributedLock = null;
    public LockingExecutorProcessor(String host, String path, int executorCount) {
        executor = Executors.newFixedThreadPool(executorCount);
        distributedLock = new DistributedLockProcessor(host, path);
    }
    public void process(List<String> locks, List<T> items, Consumer<T> consumer) throws ExecutionException, InterruptedException {
        final List<CompletableFuture<Void>> completableFutures = new ArrayList<>();
        for (int i = 0; i < locks.size(); i++) {
            final int record = i;
            CompletableFuture<Void> future =
                    CompletableFuture.runAsync(
                            () -> {
                                InterProcessLock interProcessLock = null;
                                try {
                                    interProcessLock = distributedLock.acquire(locks.get(record));
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                                if (interProcessLock != null) {
                                    consumer.accept(items.get(record));
                                }
                            }, executor);
            completableFutures.add(future);
        }
        CompletableFuture<Void> completable = CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()]));
        completable.get();
    }
}

import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;
@Service("messageService")
public interface MessageService {
    public default List<String> getMessagesList(ConfigurationsIntegrationModel.InteractionType integrationType) {
        return Arrays.asList("Message1", "Message2", "Message3","Message4");
    }
}

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
@Component("sampleJob")
public class SampleJob {
    @Autowired
    private LockingExecutorProcessor<ConfigurationsIntegrationModel> lockingExecutorProcessor;
    @Autowired
    private ConfigurationsIntegrationService configurationsIntegrationService;
    @Autowired
    private RateLimiter rateLimiter;
    @Autowired
    private MessageService messageService;

    private List<String> getLockNames(List<ConfigurationsIntegrationModel> integrationConfigurations) {
        List<String> lockNames = new ArrayList<>();
        for (ConfigurationsIntegrationModel integrationConfiguration : integrationConfigurations) {
            lockNames.add(integrationConfiguration.getLockName());
        }
        return lockNames;
    }
    @Scheduled(fixedRateString = "100")
    public void executeJob() throws ExecutionException, InterruptedException {
        List<ConfigurationsIntegrationModel> testRecords = configurationsIntegrationService.getRecords(ConfigurationsIntegrationModel.InteractionType.TEST);
        List<String> lockNames = getLockNames(testRecords);
        lockingExecutorProcessor.process(
                lockNames,
                testRecords,
                recordsConfig -> {
                    final List<CompletableFuture<Void>> completableFutures = new ArrayList<>();
                    List<String> msgList = messageService.getMessagesList(recordsConfig.getInteractionType());
                    for (String message : msgList) {
                        completableFutures.add(
                                CompletableFuture.runAsync(
                                        () -> {                                            
                                            System.out.println("Message is @@@@ "+ message);
                                        }, Executors.newFixedThreadPool(10)));
                    }
                });
    }
}

导入lombok.数据；
@资料
公共类配置集成模型{
公共枚举交互类型{
测试，
德夫；
}
私有交互类型交互类型；
私有字符串锁名；
}
导入org.springframework.stereotype.Service；
导入java.util.array；
导入java.util.List；
@服务（“配置集成服务”）
公共接口配置集成服务{
公共默认列表getRecords（ConfigurationsIntegrationModel.InteractionType集成类型）{
返回Arrays.asList（getDynamicIntegrationConfigurationMock（integrationType））；
}
私有静态配置集成模型getDynamicIntegrationConfigurationMock（配置集成模型.InteractionType集成类型）{
ConfigurationsIntegrationModel configurationsIntegration=新配置sIntegrationModel（）；
配置集成.setLockName（“测试锁”）；
configurationsIntegration.setInteractionType（集成类型）；
返回配置集成；
}
}
导入org.apache.curator.RetryPolicy；
导入org.apache.curator.framework.CuratorFramework；
导入org.apache.curator.frameworkFactory；
导入org.apache.curator.framework.recipes.locks.InterProcessLock；
导入org.apache.curator.framework.recipes.locks.interprocessSemaphoreUnitex；
导入org.apache.curator.retry.RetryNTimes；
导入java.util.concurrent.TimeUnit；
公共类分布式锁处理器{
私人馆长；
私有字符串路径；
公共分布式锁处理器（字符串主机、字符串路径）{
RetryPolicy-RetryPolicy=newretryntimes（5,90）；
client=CuratorFrameworkFactory.newClient（主机，retryPolicy）；
client.start（）；
}
公共进程间锁获取（字符串lockName）引发异常{
InterProcessSemaphoreMutex sharedLock=新的InterProcessSemaphoreMutex（客户端，路径+“/”+锁名）；
如果（！sharedLock.acquire（0，时间单位秒））{
返回null；
}
返回共享锁；
}
公共布尔释放（进程间锁sharedLock）引发异常{
sharedLock.release（）；
返回true；
}
}
导入org.apache.curator.framework.recipes.locks.InterProcessLock；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.CompletableFuture；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.Executor；
导入java.util.concurrent.Executors；
导入java.util.function.Consumer；
公共类锁定处理器{
私有执行器Executor=null；
私有distributedLock处理器distributedLock=null；
public LockingExecutorProcessor（字符串主机、字符串路径、int executorCount）{
executor=Executors.newFixedThreadPool（executorCount）；
distributedLock=新的DistributedLockProcessor（主机，路径）；
}
公共无效进程（列表锁、列表项、使用者）引发ExecutionException、InterruptedException{
最终列表completableFutures=new ArrayList（）；
对于（int i=0；i {
进程间锁进程间锁=null；
试一试{
interProcessLock=distributedLock.acquire（locks.get（record））；
}捕获（例外e）{
e、 printStackTrace（）；
}
if（进程间锁！=null）{
consumer.accept（items.get（record））；
}
}，遗嘱执行人）；
completableFutures.add（未来）；
}
CompletableFuture completable=CompletableFuture.allOf（completableFutures.toArray（新的completableFutures[completableFutures.size（））；
completable.get（）；
}
}
导入org.springframework.stereotype.Service；
导入java.util.array；
导入java.util.List；
@服务（“消息服务”）
公共接口消息服务{
公共默认列表getMessagesList（ConfigurationsIntegrationModel.InteractionType集成类型）{
返回数组.asList（“Message1”、“Message2”、“Message3”、“Message4”）；
}
}
导入com.google.common.util.concurrent.RateLimiter；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.scheduling.annotation.Scheduled；
导入org.springframework.stereotype.Component；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.CompletableFuture；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.Executors；
@组件（“sampleJob”）
公共类抽样作业{
@自动连线
私有锁定执行器处理器锁定执行器处理器；
@自动连线
专用配置集成服务配置集成服务；
@自动连线
私人税率限制器；
@自动连线
私人信息服务；
私有列表getLockNames（列表集成配置）{
List lockNames=new ArrayList（）；
用于（配置集成模型集成配置：集成配置）{
添加（integrationConfiguration.getLockName（））；
}
返回锁名；
}
@已计划（fixedRateString=“100”）
public void executeJob（）引发ExecutionException、InterruptedException{
List testRecords=configurationsIntegrationService.getRecords（ConfigurationsIntegrationModel.InteractionType.TEST）；
列出锁名
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.concurrent.ExecutionException;
    @RunWith(MockitoJUnitRunner.class)
public class SampleJobTest {
    @InjectMocks
    private SampleJob sampleJob = new SampleJob();
    @Mock
    private ConfigurationsIntegrationService configurationsIntegrationService;
    @Mock
    private MessageService messageService;
    @Mock
    private LockingExecutorProcessor<ConfigurationsIntegrationModel> lockingExecutorProcessor;

    @Test
    public void testSampleJob() throws ExecutionException, InterruptedException {
        Mockito.doCallRealMethod().when(lockingExecutorProcessor).process(Mockito.any(), Mockito.any(), Mockito.any());
        Mockito.doCallRealMethod().when(configurationsIntegrationService).getRecords(Mockito.any());
        Mockito.doCallRealMethod().when(messageService).getMessagesList(Mockito.any());
        sampleJob.executeJob();
    }
}