博客

java事件委托

  • Post author:
  • Post category:java


本案例设计到设计模式中的观察者模式(订阅发布)

一个班级，有两类学生，A类：不学习，玩，但是玩的东西不一样，有的是做游戏，与的是看电视（有点不合理）

B类：放哨的学生，专门看老师的动向，如果老师进班了就立即通知大家。

如此就形成了一个需求，放哨的学生要通知所有玩的学生：老师来了，而不同的学生有不同的反应，有的马上把电视关闭，有的停止玩游戏。

设计的要求如下，让A类学生和B类学生完全解耦，即A类完全不知道B类的学生，却可以通知B类的学生。

代码及说明如下:

Event 类，定义了一个事件类:

Code:



  1. package


    lnurd.test;



  3. import


    java.lang.reflect.Method;


  4. import


    java.util.Date;



  6. public




    class


    Event {



  7. //要执行方法的对象



  8. private


    Object object;



  9. //要执行的方法名称



  10. private


    String methodName;



  11. //要执行方法的参数



  12. private


    Object[] params;



  13. //要执行方法的参数类型



  14. private


    Class[] paramTypes;




  16. public


    Event(){


  18. }



  19. public


    Event(Object object,String methodName,Object…args){



  20. this


    .object=object;



  21. this


    .methodName=methodName;



  22. this


    .params=args;

  23. contractParamTypes(


    this


    .params);

  24. }



  25. //根据参数数组生成参数类型数组



  26. private




    void


    contractParamTypes(Object[] params){



  27. this


    .paramTypes=


    new


    Class[params.length];



  28. for


    (


    int


    i=


    0


    ;i<params.length;i++){



  29. this


    .paramTypes[i]=params[i].getClass();

  30. }

  31. }




  33. public


    Object getObject() {



  34. return


    object;

  35. }



  36. //若干setter getter省略



  37. public




    void


    setParamTypes(Class[] paramTypes) {



  38. this


    .paramTypes = paramTypes;

  39. }



  40. //执行该 对象的该方法



  41. public




    void


    invoke()


    throws


    Exception{

  42. Method method=object.getClass().getMethod(


    this


    .getMethodName(),


    this


    .getParamTypes());



  43. if


    (


    null


    ==method){



  44. return


    ;

  45. }

  46. method.invoke(


    this


    .getObject(),


    this


    .getParams());

  47. }

  48. }

EventHandler类，若干Event类的载体，同时提供一个执行所有Event的方法

Code:



  1. package


    lnurd.test;



  3. import


    java.util.ArrayList;


  4. import


    java.util.List;



  6. public




    class


    EventHandler {



  7. //是用一个List



  8. private


    List<Event> objects;




  10. public


    EventHandler(){

  11. objects=


    new


    ArrayList<Event>();

  12. }



  13. //添加某个对象要执行的事件，及需要的参数



  14. public




    void


    addEvent(Object object,String methodName,Object…args){

  15. objects.add(


    new


    Event(object,methodName,args));

  16. }



  17. //通知所有的对象执行指定的事件



  18. public




    void


    notifyX()


    throws


    Exception{



  19. for


    (Event e : objects){

  20. e.invoke();

  21. }

  22. }

  23. }

放哨的学生：这里先抽象出一个抽象类，因为放哨的人有尽职尽责的，也有马马虎虎的，

但是他们有功能的方法1。增加需要帮忙放哨的学生  2。通知所有需要放哨的学生：老师来了

Code:



  1. package


    lnurd.test;



  3. public




    abstract




    class


    Notifier {



  4. private


    EventHandler eventHandler=


    new


    EventHandler();




  6. public


    EventHandler getEventHandler() {



  7. return


    eventHandler;

  8. }



  9. public




    void


    setEventHandler(EventHandler eventHandler) {



  10. this


    .eventHandler = eventHandler;

  11. }



  12. //增加需要帮忙放哨的学生



  13. public




    abstract




    void


    addListener(Object object,String methodName,Object…args);



  14. //告诉所有要帮忙放哨的学生：老师来了



  15. public




    abstract




    void


    notifyX();

  16. }

接着是放哨人的具体实现了，这里仅实现两个

1尽职尽责的放哨人GoodNotifier

2马马虎虎的放哨人BadNotifier

Code:



  1. package


    lnurd.test;



  3. public




    class


    GoodNotifier


    extends


    Notifier {




  5. @Override



  6. public




    void


    addListener(Object object, String methodName, Object… args) {

  7. System.out.println(


    “有新的同学委托尽职尽责的放哨人!”


    );



  8. this


    .getEventHandler().addEvent(object, methodName, args);

  9. }




  11. @Override



  12. public




    void


    notifyX() {

  13. System.out.println(


    “尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了”


    );



  14. try


    {



  15. this


    .getEventHandler().notifyX();

  16. }


    catch


    (Exception e){

  17. e.printStackTrace();

  18. }

  19. }


  21. }



  23. //对于BadNotifier代码类似，不再复述.

接下来是玩游戏的学生：PlayingGameListener

Code:



  1. package


    lnurd.test;



  3. import


    java.util.Date;



  5. public




    class


    PlayingGameListener {



  6. public


    PlayingGameListener(){

  7. System.out.println(


    “我正在玩游戏 开始时间”


    +


    new


    Date());

  8. }



  9. public




    void


    stopPlayingGame(Date date){

  10. System.out.println(


    “老师来了，快回到座位上，结束时间”


    +date);

  11. }

  12. }

在接下来是看电视的学生WatchingTVListener

Code:



  1. package


    lnurd.test;



  3. import


    java.util.Date;



  5. public




    class


    WatchingTVListener {



  6. public


    WatchingTVListener(){

  7. System.out.println(


    “我正在看电视 ”


    +


    new


    Date());

  8. }



  9. public




    void


    stopWatchingTV(Date date){

  10. System.out.println(


    “老师来了，快关闭电视 。 结束时间”


    +date);

  11. }

  12. }

测试代码：

Code:



  1. //创建一个尽职尽责的放哨者

  2. Notifier goodNotifier=


    new


    GoodNotifier();



  4. //创建一个玩游戏的同学，开始玩游戏

  5. PlayingGameListener playingGameListener=


    new


    PlayingGameListener();


  6. //创建一个看电视的同学，开始看电视

  7. WatchingTVListener watchingTVListener=


    new


    WatchingTVListener();


  8. //玩游戏的同学告诉放哨的同学，老师来了告诉一下

  9. goodNotifier.addListener(playingGameListener,


    “stopPlayingGame”


    ,


    new


    Date());


  10. //看电视的同学告诉放哨的同学，老师来了告诉一下

  11. goodNotifier.addListener(watchingTVListener,


    “stopWatchingTV”


    ,


    new


    Date());


  12. try


    {



  13. //一点时间后

  14. Thread.sleep(


    1000


    );

  15. }


    catch


    (Exception e){

  16. e.printStackTrace();

  17. }


  18. //老师出现，放哨的人通知所有要帮忙的同学:老师来了

  19. goodNotifier.notifyX();
  20. 笔者总结：事件委托的本质是，我们把所有操作都当做是调用某一个实例的某一个方法（有时需要参数），那么通过java的反射，穿入实例和方法名就可以做统一的处理。


版权声明：本文为pj10405135原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Tags: