java代理模式的体现

先看以下几个类

//Hello.java
package Proxy;
/**
 * @author xueaohui
 */
public interface Hello {
    void say(String name);
    String getString();
}

package Proxy;
//HelloImpl.java
/**
 * @author xueaohui
 */
public class HelloImpl implements Hello {
    public void say(String name) {
        System.out.println("Hello " + name);
    }

    public String getString() {
        return "String";
    }
}

//HelloProxy.java
package Proxy;

import java.util.Date;

/**
 * @author xueaohui
 */
public class HelloProxy implements Hello {
    private Hello hello;
    public HelloProxy(){
        hello = new HelloImpl();
    }

    public void say(String name) {
        before();
        hello.say(name);
        after();
    }

    public String getString() {
        return "String";
    }

    private void after() {
        System.out.println(new Date().getTime());
    }

    private void before() {
        System.out.println(new Date().getTime());
    }

}

//DynamicProxy.java
package Proxy;

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

/**
 * @author xueaohui
 */
public class DynamicProxy implements InvocationHandler {
    private Object target;

    public DynamicProxy() {
    }

    public DynamicProxy(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        //想了好久 发现这就是方法的返回值
        Object result = method.invoke(target,args);
        after();
        return result;
    }

    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this
        );
    }
    private void after() {
        System.out.println(new Date().getTime());
    }

    private void before() {
        System.out.println(new Date().getTime());
    }
}

//ProxyTest.java 
package Proxy;

import org.junit.Test;

/**
 * @author xueaohui
 */
public class ProxyTest {
    @Test
    public void TestStaticProxy(){
        HelloProxy helloProxy = new HelloProxy();
        helloProxy.say("jack");

        DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl());

        Hello helloProxy = dynamicProxy.getProxy();

        String string = helloProxy.getString();
        System.out.println(string);
    }
}
/**
1466648587670
Hello jack
1466648587671
1466648587679
1466648587680
String
*/

代理模式又分为静态代理和动态代理

静态代理如HelloProxy 只能代理固定类型的接口
动态代理 可以根据传入的类型的通过实现java的InvocationHandler接口类型方法的Method.invoke(Object obj，Object[] args)从而实现传入类型的方法并返回结果

   /**
     * @param proxy 在一个莫名的方法会把本身传入作为参数传进去
     * @param method 就是我们要是实现的方法
     * @param args  就是此方法的参数
     * @return 返回方法的返回值
     */
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        //想了好久 发现这就是方法的返回值
        Object result = method.invoke(target,args);
        after();
        return result;
    }

AOP就用到了代理模式
像我们使用的before after方法就是如此
不用修改源码我们就可以
记录代理对象方法的运行时间
也可以记录运行的方法名称
。。。。