静态代理&动态代理

１、代理概念

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

　　

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

２、静态代理

　　＊接口

package com.proxy.inter;

/**
 * 定义Demo接口
 */
public interface Demo {
    public void save();
}

　　＊委托类

package com.proxy.impl;

import com.proxy.inter.Demo;

/**
 * DemoImpl实现Demo接口并覆写save()方法
 * 真实主题，执行具体业务
 */
public class DemoImpl implements Demo {
    public void save() {
        System.out.println("调用save()方法");
    }
}

　　＊代理类

package com.proxy.impl;

import com.proxy.inter.Demo;
/**
 * DemoImplProxy 也实现了Demo接口，并覆写了save()方法，增加了自己的业务 
 * 代理主题，负责其他业务的处理
 */
public class DemoImplProxy implements Demo {
    Demo demoImpl = new DemoImpl();
    
    public void save() {
        System.out.println("开始记录日志");
        demoImpl.save();
        System.out.println("开始结束日志");
    }
}

　　＊客户端

package com.proxy.impl;

import com.proxy.inter.Demo;

/**
 * 开始记录日志
 * 调用save()方法
 * 开始结束日志
 */
public class Test {
    public static void main(String[] args) {
        Demo demoImplProxy = new DemoImplProxy();
        
        demoImplProxy.save();
    }
}

３、动态代理

　　你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类，所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理。

　　在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler 接口和 java.lang.reflect.Proxy 类的支持

　　java.lang.reflect.InvocationHandler接口的定义如下：

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

　　＊Object proxy:被代理的对象

　　＊Method method:要调用的方法

　　＊Object[] args:方法调用时所需要参数

　　java.lang.reflect.Proxy类的定义如下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

　　＊CLassLoader loader:类的加载器

　　＊Class<?> interfaces:得到全部的接口

　　＊InvocationHandler h:得到InvocationHandler接口的子类的实例

　　下面来看看动态代理的具体实现

　　*接口

package com.proxy.inter;

/**
 * 定义DemoFirst接口
 */
public interface DemoFirst {
    public void saveFirst();
}

　　*委托类

package com.proxy.impl;

import com.proxy.inter.DemoFirst;

/**
 * DemoFirstImpl实现DemoFirst接口，覆写saveFirst()方法
 * 真实主题，负责执行具体业务 
 */
public class DemoFirstImpl implements DemoFirst {

    @Override
    public void saveFirst() {
        System.out.println("调用saveFirst()方法");
    }

}

　　*动态代理

package com.proxy.impl;

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

/**
 * InvocationHandlerImple实现InvocationHandler接口，覆写invoke()方法
 * 代理主题的业务写在invoke()方法中
 */
public class InvocationHandlerImpl implements InvocationHandler {

    private Object target;
    
    public InvocationHandlerImpl(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("target : " + target.getClass().getName());
        System.out.println("proxy : " + proxy.getClass().getName());
        System.out.println("method : " + method.getName());
        System.out.println("args ： " + args);
        System.out.println("开始记录日志");
        Object obj = method.invoke(target, args);
        System.out.println("结束记录日志");
        /*    
         * System.out.println("obj : " + obj.getClass().getName());
         * 本例中saveXXX方法没有返回值所以obj会报空指针异常
         */
        return obj;
    }
}

　　*客户端

package com.proxy.impl;

import java.lang.reflect.Proxy;

import com.proxy.inter.DemoFirst;
/*import com.proxy.inter.DemoSecond;*/

public class Test {
    public static void main(String[] args) {
        DemoFirst first = new DemoFirstImpl();
        /*DemoSecond second = new DemoSecondImpl();*/

        //取得代理对象
        DemoFirst firstProxy = (DemoFirst) Proxy.newProxyInstance(first
                .getClass().getClassLoader(), first.getClass().getInterfaces(),
                new InvocationHandlerImpl(first));
        //通过动态代理调用方法
        firstProxy.saveFirst();

        /*DemoSecond secondProxy = (DemoSecond) Proxy.newProxyInstance(second
                .getClass().getClassLoader(), second.getClass().getInterfaces(), 
                new InvocationHandlerImpl(second));
        secondProxy.saveSecond();*/
    }
}

执行结果如图：

如果我们需要动态代理demoSecond对象，只需要像上面注释部分那样即可

执行结果如图：

　　

我们会发现代理类Proxy会动态分配proxy对象，如图$Proxy0，$Proxy1...

动态代理的应用在很多地方都由体现，比如在开源框架Spring中的AOP（面向切面编程）...