代理：设计模式

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

图 1. 代理模式

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

 

先我先介绍下静态代理如何实现

 

/**
* 静态代理
* @author Administrator
*
*/
//接口
interface Factory {
public void create();
}
//被代理类
class NikeFactor implements Factory{
@Override
public void create() {
System.out.println("生产一批耐克衣服");
}

}

//代理类
class Proxy implements Factory{
//声明接口
Factory f;
public Proxy(Factory f) {
this.f = f;
}
@Override
public void create() {
System.out.println("代理类执行开始");
f.create();
}

}
public class Test1 {
public static void main(String[] args) {
Proxy p = new Proxy(new NikeFactor());
p.create(); //代理执行自己的方法 但是内部实际是调用被代理的方法 这个就是简单的静态代理
//如果此时我要是再有李宁的工程还得写李宁的代理这样就衍生了动态代理

}
}

为啥我们还要用动态代理我们使用静态代理不可以吗.但是你想过没有,如果我们不用动态代理我们是不是要写很多代理类,这样岂不是一个无聊的工作,就如同你买房子要找个代理,你找个媳妇要找个婚介(也算代理)哈哈哈 如果这样下去岂不是累死我们开发啊......

 

先的动态代理实现

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

/**
* 动态代理类的学习
* @author Administrator
*
*/
//动态代理使用
interface Subject{
public void action();
}
//被代理类
class RealSubject implements Subject{
@Override
public void action() {
System.out.println("我是被代理类记得执行我");
}
}

//
class MyInvocationHandler implements InvocationHandler{

Object obj ; //实现接口的被代理类的对象声明
//1, 给被代理对象的实例化即参数
//2. 返回一个代理对象 即返回值
public Object bind(Object obj){
this.obj=obj;
//这里便是动态创建代理对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), this);
}
//当通过代理对象发起对通过重写的方法调用时,都会转换如下的invoke方法的调用
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println(proxy.getClass().getName());
System.out.println(method.getName());
System.out.println(args);
Object returnobj = method.invoke(obj, args);
//System.out.println(returnobj.getClass()); //此时为空
return returnobj;
}

}

public class Test2 {

public static void main(String[] args) {
//被代理对象
Subject real = new RealSubject();
//创建一个实现了InvactionHandler接口类的对象
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
//调用blind()方法,动态返回一个同样实现了real所在类实现的接口Sub进而传统的动态代理类
Object obj = myInvocationHandler.bind(real); //这个地方返回的就是代理类的对象
Subject sub = (Subject) obj;
sub.action(); //转到对InvocationHandler接口实现类的invoke()方法的调用

//此时再用改方法调用静态代理类完成的事情
Factory f= new NikeFactor();
Factory proxyf = (Factory) myInvocationHandler.bind(f);
proxyf.create();
}
}

这样是不是很好 ,无论是买房子还是找媳妇都找一个代理就可以了.......这样是不是很好理解