Java动态代理——动态类Proxy的使用

1.什么是动态代理?

答：动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。
2.为什么使用动态代理?

答：因为动态代理可以对请求进行任何处理

3.使用它有哪些好处?

答：因为动态代理可以对请求进行任何处理
4.哪些地方需要动态代理?

答：不允许直接访问某些类；对访问要做特殊处理等

 

目前Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现

以下为模拟案例，通过动态代理实现在方法调用前后向控制台输出两句字符串

目录结构

 

定义一个HelloWorld接口

package main.aop;

/**
 * 定义一个HelloWorld接口
 * 
 * @author admin
 */
public interface IHelloWorld
{

    public void sayHelloWorld();

    /**
     * 业务处理A方法
     * 
     * @param name
     */
    void sayHello(String name);

    /**
     * 业务处理B方法
     * 
     * @param name
     */
    void sayGoogBye(String name);
}

 类HelloWorldImpl是HelloWorld接口的实现

package main.aop;

/**
 * 类HelloWorldImpl是HelloWorld接口的实现
 * 
 * @author admin
 */
public class HelloWorldImpl implements IHelloWorld
{

    public void sayHelloWorld()
    {
        System.out.println("HelloWorld!");
    }

    @Override
    public void sayHello(String name)
    {
        System.out.println("Hello " + name);
    }

    @Override
    public void sayGoogBye(String name)
    {
        System.out.println(name+" GoodBye!");
    }
}

 HelloWorldHandler是 InvocationHandler接口实现

package main.aop;

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

/**
 * 实现在方法调用前后向控制台输出两句字符串
 * 
 * @author admin
 */
public class HelloWorldHandler implements InvocationHandler
{

    // 要代理的原始对象
    private Object obj;

    public HelloWorldHandler(Object obj)
    {
        super();
        this.obj = obj;
    }

    /**
     * 在代理实例上处理方法调用并返回结果
     * 
     * @param proxy 代理类
     * @param method 被代理的方法
     * @param args 该方法的参数数组
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        Object result = null;
        // 调用之前
        doBefore();
        // 调用原始对象的方法
        result = method.invoke(obj, args);
        // 调用之后
        doAfter();
        return result;
    }

    private void doBefore()
    {
        System.out.println("before method invoke");
    }

    private void doAfter()
    {
        System.out.println("after method invoke");
    }

}

 测试类

package main.aop;

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

public class HelloWorldTest
{

    /**
     * 
     * @param args
     */
    public static void main(String[] args)
    {
        IHelloWorld helloWorld = new HelloWorldImpl();
        InvocationHandler handler = new HelloWorldHandler(helloWorld);

        // 创建动态代理对象
        IHelloWorld proxy = (IHelloWorld) Proxy.newProxyInstance(helloWorld.getClass().getClassLoader(),
                                                               helloWorld.getClass().getInterfaces(), handler);
        proxy.sayHelloWorld();
        
//        IHello hello = (IHello) new DynaProxyHello().bind(new Hello(), new LoggerOperation());
//        hello.sayGoogBye("Java Proxy");
//        hello.sayHello("Java Proxy");
    }
}