Java之静态代理和动态代理模式

静态代理和动态代理模式

1. 什么是代理模式？
   代理从字面意思来看就是，替代XX去做某事，在我们的程序中，一般替代实际对象去进行操作，扮演着中间人的角色：

客户端 –> 业务类 
客户端 –> 代理 –>业务类（代理）

1. 什么是静态代理？
   特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。

//里是静态代理的示例
//接口
interface NetWork {
    void brows();
}

//真实的服务器
class RealServer implements NetWork{
    @Override
    public void brows() {
        System.out.println("真实服务器的联网功能");
    }
}

//代理类
class ProxyServer implements NetWork{

    NetWork network;  //被代理类的对象来实例化

    public ProxyServer(NetWork network) {
        this.network = network;
    }

    @Override
    public void brows() {
        check();
        network.brows();
    }
    public void check(){
        System.out.println("代理服务器检查网络链接是否正常！");
    }
}

//主函数
public class StaticProxyInstance {


    public static void main(String arg[]) {

        NetWork network = new RealServer();
        ProxyServer proxy = new ProxyServer(network);
        proxy.brows();
    }
}

3.静态代理的不足

        缺点：
 *          不利于程序的拓展性
 *          同时每一个代理类只能有一个接口服务，
 *          如果好多类需要代理怎么办？

4.动态代理

Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
提供用于创建动态代理类和动态代理对象的静态方法
static Class<?>   getProxyClass(ClassLoader loader, Class<?>... interfaces)  创建一个动态代理类所对应的Class对象

static Object   newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  直接创建一个动态代理对象

//动态代理的例子
interface Human{
        abstract void info();
        abstract void fly();
}

//被代理类
class superMan implements Human{
    @Override
    public void info() {
        System.out.println("我是超人我怕谁");
    }

    @Override
    public void fly() {
        System.out.println("I believe I can fly!");
    }
}

//创建一个代理类

/**
 * 如何动态的的创建一个代理类的对象？
 * 有了代理类的对象如何执行被代理类的方法，不能暴露被代理类的东西？
 *
 */

class MyInvocationHandler implements InvocationHandler{

    Object obj;  //被代理类，先充当一下

    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /**
     * 当我们通过代理类的对象调用接口中的方法时，就会转为如下的invoke（）方法，去执行
     * 被代理类的方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnVal = method.invoke(obj, args);
        return returnVal;
    }

    public void bind(Object obj) {//对属性赋值
        this.obj = obj;

    }
}

class MyProxy{
    public static Object getProxyInstance(Object obj){ //被代理类的对象

        MyInvocationHandler handler = new MyInvocationHandler(obj);
        handler.bind(obj);


        //动态的返回一个代理类的对象
        //参数1：指明类的加载器
        //参数2：指明被代理类实现的接口
        //参数3：关联Handler
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass()
                .getInterfaces(),handler);
    }
}

public class ProxyInstance {

    public static void main(String arg[]) {
        superMan man = new superMan();
        Object objproxy = MyProxy.getProxyInstance(man);

        //是代理类的对象
        Human human = (Human) objproxy;


        //用代理类的对象调用方法
        human.fly();
        human.info();


    }


}

I believe I can fly!
我是超人我怕谁