设计模式之代理模式

1、静态代理
班长代理老师收班费。
// 代理类与目标类的公共接口

public interface Person{
	void collectMoney();
} 
// 目标类
public class Teacher implements Person{
	@Override
	public void collectMoney(){
		System.out.println("老师收取班费");
	}
}
public class Monitor implements Person{
	Person person;
	public Monitor(Person person){
		this.person = person;
	}
	@Override
	public void collectMoney(){
		System.out.println("班长收取班费");
		System.out.println("班长把班费交给老师");
		person.collectMoney();
		System.out.println("班长继续其他工作”);
	}
}
public class Client{
	Person teacher = new Teacher();
	Person monitor = new Monitor(teacher);
	monitor.collectMoney();
}

2、动态代理
静态代理，一个代理类只能代理具有相同接口的类。动态代理可以代理多个目标类，省去未了多个代理类的编写。

public interface Person{
	void collectMoney();
} 
public class Teacher implements Person{
	@Override
	public void collectMoney(){
		System.out.println("老师收取班费");
	}
}
public class ProxyFactory{
	private Object object;
	public ProxyFactory(Object object){
		this.object = object;
	}
	public Object getProxyInstance(){
		ClassLoader loade = object.getClass().getClassLoader();
		Class<?>[] interfaces = object.getClass.getInterfaces();
		InvocationHandler handler = new InvocationHandler(){
			@Override
			public Object invoke(Object proxy, Method method, Object[] args){
				System.out.println("可以代理任何类。目标类必须要实现至少一个接口")
				if(object instanceof Person)}{
					// 代理的是一个Perosn对象
					if(method.getName = "collectMoney"){
						System.out.println("班长代理收取班费");
					}
				}else{
					System.out.println("我还可以代理其他类")
				}
				Object object = method.invoke(args);
				return object;
			}
		}
	}
}
public class Client{
	Person teacher = new Teacher();
	ProxyFactory factory = new ProxyFactory();
	Person proxy = (Person)factory.getProxyInterface();
	proxy.collectMoney
}

静态代理中，若Person类里还有一个”收作业“的方法，而这个方法不希望经过”班长类“代理，不希望将方法暴露给”班长类“，这是无法实现的，因为班长类实现了Person类，必然要实现”收作业“的方法。动态代理，可以实现上述要求，动态代理类没有代理类，中有一个代理工厂充当代理类，最终调用方法是通过目标对象，而不是代理对象。
若系统基于静态代理，系统中有多个目标类需要被不同的代理类代理，就需要编写多个不同的代理类。动态代理可以通过instanceof关键字判断不同的类，实现一个代理工厂代理多个目标类。
3、静态代理工厂
对仿照动态代理模式对静态进行改造

public interface Animal{
	void eat();
	void sleep();
}
public class Dog{
 @Override
    public void eat() {
        System.out.println("狗狗在吃饭");
    }
    @Override
    public void Sleep() {
        System.out.println("睡觉了");
    }
 }
 public interface Peron{
 	void write();
 }
 public class ZhangSan implements Peron{
	@Override
    public void write() {
        System.out.println("张三在写字");
    }
 }
 public class ProxyFactory {
    private Object object;
    public ProxyFactory(Object object){
        this.object = object;
    }

    public void invoke(){
        if(object instanceof Dog){
            Dog dog = (Dog) object;
            System.out.println("准备狗粮");
            dog.eat();	// 只代理eat方法
            System.out.println("吃完了");
          /*  
            System.out.println("准备睡觉");
            dog.sleep();	// 也可以代理多个方法，但无法将其分开，动态代理可以根据方法名选择代理哪一个。
            System.out.println("睡醒了");
          */
        }else if(object instanceof ZhangSan){
            ZhangSan zhangSan = (ZhangSan) object;
            System.out.println("准备纸笔");
            zhangSan.write();
            System.out.println("写完了");
        }
    }
}