Java 如何使用另一个void方法阻止方法

我有一个listenner方法，它处理Spring cloud stream实现的消息，如下所示：

@StreamListener(value = MyInterface.INPUT)
public void handleMsg(@Payload Foo foo) {
    // if (concurrentHashMap.containsKey(foo.getId())) concurrentHashMap.remove(foo.getId());
}

// some logic

Foo foo = service.getFoo(fooId);

// some logic which required received foo;

这是我的第二个方法，应该被前面的方法阻止：

public Foo getFoo(long fooId) {
    // here I need block method with some mechanism until handleMsg remove received object from map and return this foo from there

    return fooFromStream;
}

我的目标是从服务类调用

getFoo

方法，如下所示：

@StreamListener(value = MyInterface.INPUT)
public void handleMsg(@Payload Foo foo) {
    // if (concurrentHashMap.containsKey(foo.getId())) concurrentHashMap.remove(foo.getId());
}

// some logic

Foo foo = service.getFoo(fooId);

// some logic which required received foo;

我曾想到将

getFoo

方法中的Foo包装成AsyncResult，并在导致阻塞的未来结果上调用下一个方法

get

，但我不知道如何将Foo从流传递到方法

getFoo

用例应该是这样的：

我调用方法

getFoo

，它将foo发送到消息代理并在map中注册foo，并执行一些逻辑，然后当命令完成时，我在streamlistener中接收消息，从map中删除foo，接下来我需要从方法

getFoo

返回该foo

---

你能告诉我怎么做，或者解决这个问题的最佳方法是什么？谢谢您的建议。

您想做什么还不完全清楚，但是

映射您可以使用长队列和阻塞队列的并发映射：

ConcurrentMap<Long, BlockingQueue<Foo>> fooMap = new ConcurrentHashMap<>();
...
private BlockingQueue<Foo> getFooQueue(long fooId) {
    return fooMap.computeIfAbsent(fooId, l -> new ArrayBlockingQueue<>(1));
}
...
@StreamListener(value = MyInterface.INPUT)
public void handleMsg(@Payload Foo foo) {
    BlockingQueue<Foo> fq = getFooQueue(foo.getId());
    synchronized(fq) {
        fq.clear();
        fq.add(foo);
    }
}
...
public Foo getFoo(long fooId) throws InterruptedException {
    BlockingQueue<Foo> fq = getFooQueue(fooId);
    synchronized(fq) {
        return fq.take();
    }
}

ConcurrentMap fooMap=新的ConcurrentHashMap（）；
...
私有阻止队列getFooQueue（长fooId）{
返回fooMap.computeIfAbsent（fooId，l->newArrayBlockingQueue（1））；
}
...
@StreamListener（值=MyInterface.INPUT）
公共无效句柄（@Payload Foo Foo）{
BlockingQueue fq=getFooQueue（foo.getId（））；
已同步（fq）{
fq.clear（）；
fq.add（foo）；
}
}
...
public Foo getFoo（long fooId）抛出InterruptedException{
BlockingQueue fq=getFooQueue（fooId）；
已同步（fq）{
返回fq.take（）；
}
}

只有当当前可用的
foo
应被新的
foo
覆盖时，可以多次调用您的
handleMsg
时，才需要这2个
synchronized
块。是否可以使用foo作为参数调用handleMsg，以及何时应该阻止getFoo handleMsg将参数编辑为null或其他什么？就Gary而言，我不认为您描述的是用例，而是IMHO有很多问题的设计。如果您从业务的角度来描述实际的用例，那确实会更好。@OlegZhurakousky您好，我需要用SpringCloud存储一些操作，并将继续进行。在每个操作过程完成后，我需要返回对等待请求的响应（getFoo方法）。好吧，如果您按顺序说，那么为什么不这样做：``` public void handleMsg（@Payload Foo Foo）{//1.保存任何需要保存的内容。如果失败，异常会传播到代理，因此不会丢失任何消息//2.在safe成功后执行任何需要的处理。}```