javaBean 关联属性，及略谈观察者模式

[color=blue][size=large][align=center][b]javaBean 关联属性，及略谈观察者模式[/b][/align][/size][/color]

[size=medium][color=blue][b]一：总述[/b][/color][/size]

概念：
[color=red][b]注入[/b][/color] 是指：
当有A,B两个类时，通过B的公共函数或公共变量，让B的实例保存A的实例的过程。当然了，B类中，必须有 A的相关变量，否则无从存储。

例：

class A {}
class B{
    private A a;
    public void setA(A a){
        this.a=a;
    }
}

当使用中出现“A aaa=new A(); B bbb=new B(); bbb.setA(aaa); ”代码时
称“向B注入了一个实列”；或称“把A实例注入到B实例中了”。


观察模式，就是实现“一处(A)变化，其他多处地方(B)跟着相应变化”的设计模式。基本思想是：让A调用B的方法。一般实现是：把A，B封装在各自类中，并引入一个新的中间类，完成管理任务，这里称之为管理者，符号表示为C。当A发生变化时，调用C的通知函数，而C又调用B的约定的接收函数，B在接收函数中完成相应变化。具体为：在使用时， C的实例注入到A中，并事前A调用C的通知函数；同时，B也向C注入，并事前C调用B的接收函数。其中 C中的B的相关变量类型，为B的基类，或B必须实现的接口。
观察模式中有两个概念-----监听者与被监听者。被监听者，就是要发生变化的一方（即上段中的A）；监听者，就是被通知方（即上段中的B）。当要变化的一方发生变化时，监听者要调用B的相关方法，让B随之变化。
事件本质，可抽象成观察者模式。要让各个具体的观察者模式 通用到各种场合，最好的方式就是使用自定义事件。对于C#等，还可使用委托（delegate）；对于java，可使用关联属性。

[b][color=blue][size=medium]二 关联属性总的使用步骤[/size][/color][/b]

(1) 在被监听者中，添加PropertyChangeSupport 对象。

 private PropertyChangeSupport changes = new PropertyChangeSupport(this);

(2) 在被 监听者中，添加注册与注销函数。

public void addPropertyChangeListener (PropertyChangeListener listener) {
      changes.addPropertyChangeListener(listener);
}

public void removePropertyChangeListener (PropertyChangeListener listener) {
    changes.removePropertyChangeListener (listener);
}

(3) 当被监听属性发生变化时，调用firePropertyChange方法。
changes.firePropertyChange("no", this.no, no);

(4) 在被通知方（即监听者）里，必须实现PropertyChangeListener接口
class UseCase implements PropertyChangeListener {

(5) 在被通知方里，向通知方进行注册。Std是通知方的一个实例

public UseCase(Student std){
    this.std=std;
    this.std.addPropertyChangeListener(this);
}

(6) 在被知方里，实现propertyChange方法。这是PropertyChangeListener接口的方法。

public void propertyChange(PropertyChangeEvent evt) {      
    if ( (evt.getSource().getClass().equals(Student.class)) &&
            (evt.getPropertyName().equals("no"))   ) {  
         no="由"+evt.getOldValue()+"变成"+evt.getNewValue();       
    }          
}

[color=red][b][size=medium]注：[/size][/b][/color]总的运行原理：初始化时，通知方申请了 一个通用管理者(PropertyChangeSupportc的实例)，并以该管理者为基础，向外提供注册与注销的函数；而被通知方，必须实现 管理者提供的完成接收通知的方法（PropertyChangeListener 口的propertyChange函数）。这样，当属性发生变化时，通知方调用管理者的firePropertyChange函数（即通知方法），而管理者调用向他注册过的被通知方的 propertyChange函数（即接收通知的方法），从而让被通知方相应发生变化。


[b][color=blue][size=medium]三 完整示例[/size][/color][/b]：

import java.awt.Component;
import java.awt.Container;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.SpringLayout;


/**
 * 测试javaBean 的关联属性。<br/>
 * 关联属性，可以简单理解成 一个属性变化事件。<br/>
 * 运用场合，可以是观察模式所应用场所，即一处变化，其他别处也将跟随变化.<br/>
 * 本示例，展示了，Student对象的no变化时，UseCase对象的no跟着变化。
 * @author cloud
 */
public class MainTest {
    /**
     * 内部类，一个javaBean. no为 被监控的属性，他一变化，就会通知监控他的对象相应变化。<br/>
     * 这里，必须定义一个PropertyChangeSupport 对象。 当属性变化时，将使用该对象的
     * firePropertyChange 方法，通知要变化的其他类实例，当然，在使用前需要完成注册。
     * 
     */
    class Student {
        /**
         * 定义了一个PropertyChangeSupport对象。这是必须的。
         */
        private PropertyChangeSupport changes = new PropertyChangeSupport(this);
        private String no="张三";

        public String getNo() {
            return no;
        }

        /**
         * 当no变化时，这里先要调用firePropertyChange ，发布通知。<br/>
         * 其中第一个参数 重新定义了属性名，以便被通知方区别接收。
         */
        public void setNo(String no) {
            changes.firePropertyChange("no", this.no, no);
            this.no = no;

        }
        /**
         * 注册 需要通知的其他类实例
         */
        public void addPropertyChangeListener (PropertyChangeListener listener) {
            changes.addPropertyChangeListener(listener);
        }
        /**
         * 注销 需要通知的其他类实例
         */
        public void removePropertyChangeListener    (PropertyChangeListener listener) {
           changes.removePropertyChangeListener (listener);
        }

    }

    /**
     * 这是一个需要接收属性变化的类，或即是一个监听者，他要监听一个属性变化。<br/>
     * 必须继承 PropertyChangeListener接口，并实现propertyChange方法。
     */
    class UseCase implements PropertyChangeListener  {
        public  String no="";
        private  Student std;
        /**
         * 生成实例时，必须注入一个被监听的类实例
         */
        public UseCase(Student std){
            this.std=std;
            /**
             * 向被监听者 进行注册，表示自已需要监察其属生变化
             */
            this.std.addPropertyChangeListener(this);
        }


        @Override
        public void propertyChange(PropertyChangeEvent evt) {      
            /**
             * 有可能 该监听者，有众多不同的需要监听的类实例，所以有第一个判断。<br/>
             * 又有可能 同一个类需要监听的属性有多个，所以有第二个判断。<br/>
             * 当然在被监听者中，在发布通知时，进行编码，可以达到去除第一个判断的作用。
             */
            if ( (evt.getSource().getClass().equals(Student.class)) &&
                    (evt.getPropertyName().equals("no"))   ) {  
                 no="由"+evt.getOldValue()+"变成"+evt.getNewValue();       
            }          
        }

    }

    /**
     * 测试方法
     */
    public void run(){        
        Student sdt=new Student();
        UseCase u=new UseCase(sdt);
        System.out.println("========显示初值===============");
        System.out.println("sdt.no:"+sdt.no+"          ;u.no:"+u.no);  

        System.out.println("========属性改变，并显示========");
        sdt.setNo("李四");
        System.out.println("sdt.no:"+sdt.no+"          ;u.no:"+u.no);  
    }
    public static void main(String args[]) {
        MainTest ma=new MainTest();
        ma.run();

    }
}

运行结果：
[quote]========显示初值===============
sdt.no:张三 ;u.no:
========属性改变，并显示========
sdt.no:李四 ;u.no:由张三变成李四[/quote]