静态代理&动态代理

 

代理设计在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（面向切面编程）...