EJB 回调

EJB 回调是一种在企业级 Java 应用程序中使用的设计模式。EJB 回调用于在 EJB 组件之间进行通信，并且它允许一个组件在另一个组件中注册回调对象以接收回调通知。

回调实现

回调实现主要有两种方式：同步与异步。

同步回调

同步回调是指回调发生后，必须立即完成回调，然后再继续执行调用者的代码。同步回调通常使用接口，或抽象类作为回调目标并实现相应的接口方法，这些方法将被回调接收者所调用。

例如：

public interface Callback {
    void onChange(int newValue);
}

public class Caller {
    private Callback callback;

    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    public void performOperation(int value) {
        // 执行相应的操作
        if (this.callback != null) {
            this.callback.onChange(value);
        }
    }
}

public class Receiver implements Callback {
    @Override
    public void onChange(int newValue) {
        System.out.println("New value: " + newValue);
    }
}

// 使用示例
Caller caller = new Caller();
Receiver receiver = new Receiver();

caller.setCallback(receiver);
caller.performOperation(42);

异步回调

异步回调则是相对的，回调发生后，不直接通知调用者，而是让一个特定的接口或类去执行回调操作，常见的形式是让一个线程池去执行回调操作。

例如：

public interface AsyncCallback<T> {
    void onSuccess(T result);
    void onError(Exception e);
}

public class AsyncCaller {
    private ExecutorService executor = Executors.newFixedThreadPool(10);

    public <T> void performAsyncOperation(Callable<T> callable, AsyncCallback<T> callback) {
        this.executor.submit(() -> {
            try {
                T result = callable.call();
                callback.onSuccess(result);
            } catch (Exception e) {
                callback.onError(e);
            }
        });
    }
}

// 使用示例
AsyncCaller caller = new AsyncCaller();
AsyncCallback<Integer> callback = new AsyncCallback<Integer>() {
    @Override
    public void onSuccess(Integer result) {
        System.out.println("Result: " + result);
    }

    @Override
    public void onError(Exception e) {
        e.printStackTrace();
    }
};

caller.performAsyncOperation(() -> {
    return 42;
}, callback);

EJB 回调

虽然使用接口或类作为回调目标相对简单，但在 EJB 组件之间进行通信时不总是适用。在这种情况下，EJB 回调模式可以使用。EJB 回调是使用 EJB 组件之间传递的 Java 对象来完成的，包括消息、事件和状态。

Session Beans 回调

Session Bean 回调指在另一个 EJB 实例上注册回调。此外，EJB 组件还可以向回调对象提供一些状态信息。

例如，在一个 Session Bean 中，我们可以定义一个接口并实现相应的方法：

public interface Callback {
    void onEvent(Event event);
}

@Stateless
public class EventProcessorBean {
    @EJB
    private CallbackRegistry registry;

    public void processEvent(Event event) {
        this.registry.callback(event);
    }
}

@LocalBean
@Stateless
public class CallbackRegistry {
    private Map<String, Callback> callbacks = new HashMap<>();

    public String register(Callback callback) {
        String key = UUID.randomUUID().toString();
        this.callbacks.put(key, callback);
        return key;
    }

    public void unregister(String key) {
        this.callbacks.remove(key);
    }

    public void callback(Event event) {
        for (Callback callback : callbacks.values()) {
            callback.onEvent(event);
        }
    }
}

在上面的例子中，EventProcessorBean 将事件传递给回调注册表，然后由回调注册表通知已注册的所有回调。回调注册表维护了所有已注册回调对象的 Map。

现在我们来看一下如何用一个 Session Bean 注册一个回调：

@Local
public interface CallbackService {
    String register(Callback callback);
    void unregister(String key);
}

@Stateless
public class CallbackBean implements CallbackService, Callback {
    private String key;
    @EJB
    private CallbackRegistry registry;

    @Override
    public void onEvent(Event event) {
        System.out.println("Received event: " + event);
    }

    @Override
    public String register(Callback callback) {
        this.key = this.registry.register(callback);
        return this.key;
    }

    @Override
    public void unregister(String key) {
        this.registry.unregister(key);
    }
}

CallbackBean 实现了 CallbackService 和 Callback 接口，它将自己注册到 CallbackRegistry 中，并在 Callback 接口的 onEvent 方法中处理回到。

这个例子解释了当一个 EJB 组件在另一个 EJB 组件上注册回调时，如何在 EJB 组件之间传递事件消息。

Entity Beans 回调

除了 Session Beans 回调，EJB 3.0 还支持在 Entity Beans 之间执行回调。

例如，我们可以定义一个回调接口：

public interface Callback {
    void onEvent(Event event);
}

然后，我们可以定义一个实体 Bean，它实现了该接口：

@Entity
@Table(name = "event")
public class Event implements Serializable, Callback {
    // 实体 Bean 的属性

    @Override
    public void onEvent(Event event) {
        System.out.println("Received event: " + event);
    }
}

@Stateless
public class EventProcessorBean {
    @PersistenceContext
    private EntityManager entityManager;

    public void processEvent(Event event) {
        this.entityManager.persist(event);
        event.onEvent(event);
    }
}

在上述代码中，当 EventProcessorBean 将事件传递给 Entity Bean 时，它会在事件上调用回调方法。

总结

本文介绍了 EJB 回调，它是一种在企业级 Java 应用程序中实现组件间通信的设计模式，它允许组件在另一个组件中注册回调对象以接收回调通知。

回调实现包括同步与异步，它们可以使用接口或抽象类来实现回调。

对于 EJB 组件之间回调通信，我们介绍了 Session Beans 回调和 Entity Beans 回调，它们都是使用 EJB 组件之间传递的 Java 对象来完成回调。

以上就是本文的内容，它涵盖了 EJB 回调模式的基本概念，以及如何在企业级 Java 应用程序中使用回调。