java 设计模式之初探代理模式

代理模式就是多一个代理类出来，替原对象进行一些操作，
比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找
一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因
为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图

这里写图片描述

我们废话不多说直接上代码:

public class Source implements Sourceable {

    @Override
    public void method() {
    System.out.println("this is souce method");

    }

}

public interface Sourceable {


    public void method();
}

public class Porxy implements Sourceable{


    private Sourceable source;



    public Porxy(Sourceable source) {
        super();
        this.source = source;
    }

    @Override
    public void method() {
        before();
        source.method();
        after();


    }

    public void before(){
        System.out.println("before porxy");
    }

    public void after(){
        System.out.println("after porxy");
    }
}

看上面的代码像不像aop 哈哈.


public class PorxyTest {

    public static void main(String[] args) {

        Sourceable s = new Source();

        Porxy p = new Porxy(s);

        p.method();
    }
}
before porxy
this is souce method
after porxy

代理模式和装饰模式很像但是被代理的类并不知道自己已经被代理过了.
被装饰者一定知道自己被装饰过
装饰模式:主要是增强方法
代理模式: 主要是限制方法

观察模式

观察者模式很好理解，类似于邮件订阅和 RSS 订阅，当我们浏览一
些博客或 wiki 时，经常会看到 RSS 图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及
时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且
随着变化！对象之间是一种一对多的关系。先来看看关系图：

这里写图片描述

我解释下这些类的作用：MySubject 类就是我们的主对象，Observer1 和 Observer2 是依赖于 MySubject
的对象，当 MySubject 变化时， Observer1 和 Observer2 必然变化。 AbstractSubject 类中定义着需要
监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当 MySubject 变化时，负责通知在
列表内存在的对象。我们看实现代码：

//一个observer的  接口
public interface Observer {

    public void update();

}

//实现类
public class Observer1 implements Observer{

    @Override
    public void update() {

        System.out.println("observer1 has received");
    }

}


public class Observer2 implements Observer{

    @Override
    public void update() {

        System.out.println("observer2 has reveived");
    }

}

public interface Subject {
    /**
     * 增加 observer
     */
    public void add(Observer server);
    /*删除观察者*/  
    public void del(Observer observer);  

    /*通知所有的观察者*/  
    public void notifyObservers();  

    /*自身的操作*/  
    public void operation();  

}

public abstract class AbstractSubject implements Subject{

    //Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。
    private Vector<Observer> vo =  new Vector<Observer>();

    @Override
    public void add(Observer server) {
        vo.add(server);

    }

    @Override
    public void del(Observer observer) {
        vo.remove(observer);
    }

    @Override
    public void notifyObservers() {

            Enumeration<Observer> elements = vo.elements();

            while (elements.hasMoreElements()) {
                 elements.nextElement().update();

            }
    }


}

public class MySubject extends AbstractSubject{

    @Override
    public void operation() {

        System.out.println("update self");

        notifyObservers();

    }

}

测试类:

public class Test {

     public static void main(String[] args) {  
            Subject sub = new MySubject();  
            sub.add(new Observer1());  
            sub.add(new Observer2());  

            sub.operation();  
        }  

}

update self
observer1 has received
observer2 has reveived

java 设计模式之初探代理模式

观察模式

猜你喜欢