代理设计模式的原理:
使用一个代理将对象包装起来,然后用该代理对象去取代原始对象。任何对原始对象的调用都需要通过代理。代理对象决定是否以及何时将方法调用转移到原始对象上.
1 、静态代理
//接口
interface Subject{
void action();
}
//被代理类
class RealSubject implements Subject{
@Override
public void action() {
System.out.println("这里是被代理类的action()方法");
}
}
//静态代理类
public class StaticProxy implements Subject {
public Subject subject;
public StaticProxy(Subject subject) {
this.subject = subject;
}
@Override
public void action() {
subject.action();
}
public static void main(String[] args) {
StaticProxy staticProxy=new StaticProxy(new RealSubject());
staticProxy.action();
}
}
2、动态代理
动态代理是指客户通过代理类来调其他对象的方法,并且是在程序运行时根据需要动态的创建目标类的代理对象。
创建动态代理需要实现InvocationHandler接口
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Objects;
//接口
interface Subject{
void action();
}
//被代理类
class RealSubject implements Subject{
@Override
public void action() {
System.out.println("这里是被代理类的action()方法!");
}
}
//代理类
class MyInvocationHandler implements InvocationHandler{
Object object;
//完成对object的初始化,返回一个Proxy的实例
public Object blind(Object object){
this.object=object;
//Proxy.newProxyInstance返回指定接口的代理类Class,该接口将方法调用分派给指定的调用处理程序(this)。
return Proxy.newProxyInstance(object.getClass().getClassLoader(),
object.getClass().getInterfaces(), this);
}
@Override
//当通过代理类的对象发起对被重写的方法的调用时,都会转化为对如下的invoke方法调用
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态调用方法,调用目标方法
Object returnVal=method.invoke(object,args);
return returnVal;
}
}
public class TestProxy {
public static void main(String[] args) {
//创建一个被代理类的对象
RealSubject real=new RealSubject();
//创建一个实现Invocation所有接口的对象
MyInvocationHandler handler=new MyInvocationHandler();
//调用blind()方法,动态的返回一个同样实现了real所在类,实现的接口Subject的代理类对象
Object obj=handler.blind(real);
Subject sub=(Subject)obj;//此时的sub就是代理类的对象
sub.action();//转到MyInvocationHandler的invoke方法
}
}