Java代理模式

一静态代理：

当无法访问一个对象或者访问一个对象有困难的时候可以为这个对象提供一个代理，代理者与被代理者应该实现相同的接口，或者继承同一个抽象类。

被代理者：

public class Student implements Study{

	@Override
	public void read() {
		System.out.print("read a book");
		
	}

	@Override
	public void write() {
		System.out.print("write a book");
		
	}

}

代理者：

public class Teacher implements Study{
	private Student student;
	public Teacher(Student student)
	{
		this.student=student;
	}

	@Override
	public void read() {
		student.read();
		
	}

	@Override
	public void write() {
		student.write();
		
	}

}

需要实现相同的接口或者继承相同的抽象类：

public interface Study {
	void read();
	void write();
}

main 方法实现：

public class School {

	public static void main(String[] args) {
		Student student=new Student();
		Teacher teacher=new Teacher(student);
		teacher.read();
		teacher.write();

	}

}

我们可以理解为一个学生他不想学习，把读书的工作还有写书的工作都交给老师，让老师来做。 虽然在Java代码中我们可以通过静态代理模式实现，但是在现实中....嘿嘿嘿

二动态代理：

我们发现每个代理都需要一个代理类，这样的话类越多代码量越大，重复的行为也很多，这时候就用到了动态代理模式。

在Java代码中提供了一个InvocationHandler接口，需要实现invoke方法。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxy implements InvocationHandler{
	

	private Object object;

	public Object bind(Object object)
    {
        this.object = object;
      
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
        		object.getClass().getInterfaces(),
                                      this);
    }    


	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

		Object result = null;
		result=method.invoke(object, args);
		return result;
	}

}

在main方法中调用：

public class School {

	public static void main(String[] args) {
		Student student=new Student();
		DynamicProxy proxy=new DynamicProxy();
		Study study=(Study)proxy.bind(student);
		study.read();
		study.write();

	}

}

Java通过反射机制得到一个动态代理，这个时候就不需要静态代理的Teacher类，这个时候通过动态代理的反射机制形成一个Study接口类。