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 哈哈.

4000

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