اقتران المناسب لتعدد المستمعين التي تحتاج إلى الوصول إلى بيانات حالة المشتركة

Question

العمل مع نموذج المستمع رد التقليدي. لدي العديد من المستمعين أن جمع الاشياء المختلفة. الاشياء التي جمعت كل المستمع هو داخل المستمع في الهياكل الداخلية.

والمشكلة هي أنني أريد بعض المستمعين ليكون على بينة من بعض "الاشياء" في المستمعين الآخرين.

وI فرض النظام تسجيل المستمع، حتى لو كنت علم تسجيل الأحداث في بعض الأمر مستمعا لاحق يمكن أن يكون على يقين من أن مستمع سابقا تحديث الاشياء، وبطريقة أو بأخرى الوصول إليه لبذل المزيد من الاشياء.

وأول محاولة لي في هذا هو أن يكون كل مستمع تخزين إشارة إلى المستمعين التي تعتمد عليها. لذا أسجل المستمعين في ترتيب تلك دون تبعيات لذوي التبعيات السابقة المسجلة، ثم قم بتعيين مراجع بين المستمعين في طرق مختلفة.

وأنا بدأت أدرك مدى سوء يشعر هذا وأنا أتساءل عما إذا كان قد تم بطريقة أو بأخرى على هذا الطريق من قبل. ما يمكن أن يكون نمط أكثر ملاءمة عندما يحتاج أحد المستمعين للوصول إلى الأشياء في بلد آخر؟

وهنا بعض شبة الكود لتوضيح:

interface Listener { onEvent(char e); }

class A implements Listener {
  private int count;
  public void onEvent(char  e) { if(e == 'a') count++; }
  public int getCount() { return count; }
}

class B implements Listener {
 private int count;
 // private A a;
 // private void setA(A a) { this.a = a; }

 public void onEvent(char  e) { if(e == 'b') count++; }
 public int getCount() { return count; }
 public int getAPlusBCount() {
   // We know B count, but we don't know A so how would we change this 
   // so B is A aware? Or not even aware, just somehow coupled? This
   // is the question
   // return a.getCount() + count;
 }

 public void doConditionalHere() {
  // Do some condition in B that relies on the state of data in A
  int acount = 0; // a.getCount(); ???
  if(acount % 2 == 0) {
   this.count--;
  }
 }
}

class Run {
 A a = new A();
 B b = new B();
 List listeners = new List();
 listeners.add(a);
 listeners.add(b);

 // The ugly way I add coupling right now is to keep a reference to A
 // inside B. It's commented out because I am hoping there is a more intelligent approach
 // b.setA(a);

 for(char c : "ababbabab") {
   for(listener : listeners) {
     listener.onEvent(c);
   }
 }
}

Answer 1

لماذا لا يكون كائن المركزي الذي سوف تتبع عدد المرات التي أطلق طريقة onEvent لجميع الطبقات المستمع

 public interface CountObserver {

 public void updateCount(String className);
 public int getCount(String className);
}

public class CentralObserver implements CountObserver {

 private int aCount;
 private int bCount;

 public void updateCount(String className) {

 //There's probably a better way to do this than using
 //all these if-elses, but you'll get the idea.

  if (className.equals("AclassName")) {
   aCount++;
  }
  else if (className.equals("BclassName")) {
   bCount++;
  }
 }

 public int getCount(String className) {

  if (className.equals("AclassName")) {
   return aCount;
  }
  else if (className.equals("BclassName")) {
   return bCount;
  }
}

class A implements Listener {

 CountObserver countObserver;

 public void registerObserver (CountObserver countObserver) {

  this.countObserver = countObserver;
 }

 public void onEvent(char e) {

  if(e == 'a') {

   countObserver.updateCount (this.getClass.getName);
  }
 }

}

//Same thing for B or any other class implementing Listener. Your Listener interface should, of 

//course, have a method signature for the registerObserver method which all the listener classes 

//will implement.

class Run {

 private A a;
 private B b; 
 private CountObserver centralObserver;

 public runProgram () {

  centralObserver = new CentralObserver();
  a.registerObserver(centralObserver);
  b.registerObserver(centralObserver);

 //run OnEvent method for A a couple of times, then for B

 }

 public int getAcount () {

 return centralObserver.getCount(a.getClass.getName());
 }

 public int getBcount () {

 return centralObserver.getCount(b.getClass.getName());
 }
} 
 //To get the sum of all the counts just call getAcount + getBcount. Of course, you can always  add more listeners and more getXCount methods

Answer 2

ولقد وصف الكثير من اقتران هنا. من الأفضل أن يكون للقضاء على جميع هذه التبعية القنوات الخلفية، ولكن إذا تعذر ذلك ربما يمكن أن يكون هؤلاء مع تبعيات الاستماع ليس على القائمة الأولية المستمع، ولكن على أي أنها تعتمد على. أو هل يمكن أن يكون لهم الانتظار حتى لديهم كل الإشارات.

هل يمكن أتمتة إدارة الاعتماد عن طريق الحصول على المستمعين تحديد من هم يعتمدون عليها. سيتم أمرت قائمة المستمع ليس من أجل الإدراج، ولكن لضمان الكائنات التابعة تتبع اعتمادها. سيكون واجهة المستمع الخاص ننظر بشيء من هذا القبيل:

interface Listener {
  String getId();
  Collection<String> getDependencies();
  onEvent(char e);
}

وأو يكون مجرد إشارات، كما يلي:

interface Listener {
  Collection<Listener> getDependencies();
  onEvent(char e);
}

Answer 3

و"كيف يمكن ان نغير هذا بحيث المستمع B هو المستمع وعلم أم لا حتى على علم، فقط يقترن بطريقة أو بأخرى؟"

وأنت لا ما تريد ان كائنين الزوجين "النظير" من هذا القبيل. تريد اثنين من أقرانه إلى يتوقف على شيء مشترك.

والسؤال الأعمق هو ما لا المستمع A أو B المستمع القيام به مع جميع المعلومات التي يجمعونها؟

والمستمع كثيرا ما يفعل شيئين: انها تقوم بجمع البيانات ويستغرق العمل. في كثير من الأحيان لا بد من فصل هذين الأمرين. يجب المستمعين الاستماع وجمع وبذل المزيد من الجهد قليلا. بعض وجوه الآخرين (ق) يمكن تفعيلها من خلال المستمع.

وماذا قد يكون لديك واحد فقط هو المستمع الذي لديه العديد من الإجراءات (A و B). يمكن للمستمع ثم توفير التهم المناسبة لA وكذلك B. وهو يوفر 'ا' عد إلى A. وهي توفر "أ" أو "ب" العد إلى B.