我一直在尝试使用Mark Rajcok发布的答案
angular JS - communicate between non-dependend services
我无法理解他的答案。特别是这部分：
angular.forEach(event1ServiceHandlers, function(handler) {
handler(some_data);
});
event1ServiceHandlers数组是否填充了在此forEach循环中触发的函数（此处称为handler）？
我认为通过一个很好的例子来理解如何设置发布/订阅会更容易。
我有两个需要沟通的服务，但我想避免使用$ rootScope。$ broadcast所以从我读过的pub / sub服务是最好的方法。我的一个服务需要在我的其他服务上执行一个函数，但是该服务已经将我的第一个服务作为依赖项，所以由于循环依赖性，我不能两种方式都这样做。
我的问题：假设您有两个angularjs服务（工厂），如果服务2已经将服务1作为依赖项，服务1如何在服务2上执行功能。不使用$ broadcast和$ on
答案 0 :(得分：1)
event1ServiceHandlers数组是否填充了在此forEach循环中触发的函数（此处称为handler）？
是
如果服务2已将服务1作为依赖项
，则服务1如何在服务2上执行功能
像以前一样创建服务3，public class MyTest {
public void sayHello(Supplier<String> myGetter) {
System.out.println("Hello " + myGetter.get());
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException {
Person person = new Person("Michal", "Lefler");
MyTest myTest = new MyTest();
List<Supplier<String>> suppliers = new ArrayList<>();
Method[] methods = Person.class.getMethods();
for (Method method : methods) {
if (!method.isAnnotationPresent(NameMethod.class))
continue;
MethodType desc = MethodType.methodType(String.class);
MethodHandle methodHandle = MethodHandles.lookup().findVirtual(
Person.class, method.getName(), desc);
suppliers.add(new NameSupplier<>(methodHandle, person));
}
suppliers.forEach(myTest::sayHello);
}
static class Person {
private String name;
private String lastName;
public Person(String name, String lastName) {
this.name = name;
this.lastName = lastName;
}
@NameMethod
public String getName() {
return name;
}
@NameMethod
public String getLastName() {
return lastName;
}
public String getBlahBlah() {
return "BlahBlah";
}
public String getPakaPaka() {
return "PakaPaka";
}
}
@Retention(value= RetentionPolicy.RUNTIME)
@interface NameMethod {}
public static class NameSupplier<T> implements Supplier<String> {
private final MethodHandle methodHandle;
private final T object;
public NameSupplier(MethodHandle methodHandle, T object) {
this.methodHandle = methodHandle;
this.object = object;
}
@Override
public String get() {
try {
return (String) methodHandle.invoke(object);
} catch (Throwable throwable) {
throw new RuntimeException(throwable);
}
}
}
}
：
NotificationService让服务2使用.factory('NotificationService', [function() {
var event1ServiceHandlers = [];
return {
// publish
event1Happened: function(some_data) {
angular.forEach(event1ServiceHandlers, function(handler) {
handler(some_data);
});
},
// subscribe
onEvent1: function(handler) {
event1ServiceHandlers.push(handler);
}
};
}])
注册回调函数：
NotificationService每当服务1希望服务2上的函数.factory('Service2', ['NotificationService',
function(NotificationService) {
// event1 handler
var doSomething = function(someData) {
console.log('S2', someData);
// do something here
}
// subscribe to event1
NotificationService.onEvent1(doSomething);
return {
// define public API for Service2 here
}
}])
执行时，它就可以发布doSomething()事件：
event1Happened答案 1 :(得分：-1)
在他的示例中，NotificationService是任何现有服务所依赖的新服务。他提供了Service1的实现，但Service2基本上是相同的......都取决于NotificationService而且彼此都不了解。
Service1和Service2每个人都通过调用NotificationService.onEvent1(event1Happened);来订阅活动，并通过调用NotificationService.event1Happened(my_data);来触发事件。