Java的动态代理

Proxy.newProxyInstance(loader, interfaces, h)参数说明
　　　loader: 代理对象使用的类加载器。 ClassLoader loader=target.getClass().getClassLoader();
　　　interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法. Class[] interfaces=new Class[]{HaveproxyObject.class}
　　　h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法

　InvocationHandler h=new InvocationHandler() {public Object invoke(Object proxy, Method method, Object[] args){}参数说明
　　　　　　　　　　　　　　　　proxy: 代理对象。 一般不在invoke方法里不使用该对象，以避免陷入死循环
　　　　　　　　　　　　　　　　method: 正在被调用的方法，也就SpringAOP所说的连接点，
　　　　　　　　　　　　　　　　args: 调用方法传入的参数，也就是调用业务逻辑类的方法时传递的参数

            package
             com.jeremy.spring.InvocationHandler;


            public
            class ArithmeticCalculatorImpl implements ArithmeticCalculator {

    @Override
    publicint add(int i, int j) {
        int result =i+j;
        System.out.println(this.getClass()+"     "+this.hashCode());//只是测试是否为同一个对象
        return result;
    }

    @Override
    publicint sub(int i, int j) {
        int result =i-j;
        return result;
    }

    @Override
    publicint mul(int i, int j) {
        int result =i*j;
        return result;
    }

    @Override
    publicint div(int i, int j) {
        int result =i/j;
        return result;
    }

}

            package
             com.jeremy.spring.InvocationHandler;


            import
             java.lang.reflect.InvocationHandler;

            import
             java.lang.reflect.Method;

            import
             java.lang.reflect.Proxy;


            public
            class
             ArithmeticCalculatorProxy {
　　//第二步包裹业务逻辑类
    
            private ArithmeticCalculator target=null;
    /*
     * 使用构造方法传递要代理的对象（第三步取得需要代理的对象）
     */public ArithmeticCalculatorProxy(ArithmeticCalculator arithmeticCalculator) {
        this.target=arithmeticCalculator;
    }
    
    /*
     * 返回代理对象，（第四步取得代理对象，使用Proxy.newProxyInstance（）方法）也就是返回ArithmeticCalculator对象，为什么要返回呢？？
     */public ArithmeticCalculator getLoggingProxy(){
        ArithmeticCalculator proxy = null;
        ClassLoader loader=target.getClass().getClassLoader();
        Class[] interfaces=new Class[]{ArithmeticCalculator.class};
　　　　//第五步使用invacatioHandler的invoke()方法，实现调用业务逻辑类的方法前后需要实现的功能
        InvocationHandler h=new InvocationHandler() {
            
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                    Object result = null;

                                result = method.invoke(target, args);//Method.invoke():方法就是去执行逻辑类的方法
                return result;
            }
        };
        /**
         * loader: 代理对象使用的类加载器。 
         * interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法. 
         * h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法
         */
        
        proxy=(ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
        System.out.println(proxy.getClass()+"     "+proxy.hashCode());//只是为 测试是否是同一个对象
        return proxy;
    }
}

                @Test
    
            public
            void
             test() {
        ArithmeticCalculator aImpl=new ArithmeticCalculatorImpl();
        aImpl=new ArithmeticCalculatorProxy(aImpl).getLoggingProxy();
        int result=aImpl.add(1, 2);
        System.out.println(result);
    }