Java动态代理机制

/**
 * {@code InvocationHandler} is the interface implemented by
 * the <i>invocation handler</i> of a proxy instance.
 *
 * <p>Each proxy instance has an associated invocation handler.
 * When a method is invoked on a proxy instance, the method
 * invocation is encoded and dispatched to the {@code invoke}
 * method of its invocation handler.
 *
 * @author      Peter Jones
 * @see         Proxy
 * @since       1.3
 */

/**
     * Processes a method invocation on a proxy instance and returns
     * the result.  This method will be invoked on an invocation handler
     * when a method is invoked on a proxy instance that it is
     * associated with.
     *
     * @param   proxy the proxy instance that the method was invoked on
     *
     * @param   method the {@code Method} instance corresponding to
     * the interface method invoked on the proxy instance.  The declaring
     * class of the {@code Method} object will be the interface that
     * the method was declared in, which may be a superinterface of the
     * proxy interface that the proxy class inherits the method through.
     *
     * @param   args an array of objects containing the values of the
     * arguments passed in the method invocation on the proxy instance,
     * or {@code null} if interface method takes no arguments.
     * Arguments of primitive types are wrapped in instances of the
     * appropriate primitive wrapper class, such as
     * {@code java.lang.Integer} or {@code java.lang.Boolean}.
     *
     * @return  the value to return from the method invocation on the
     * proxy instance.  */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

/**
 * {@code Proxy} provides static methods for creating dynamic proxy
 * classes and instances, and it is also the superclass of all
 * dynamic proxy classes created by those methods.
 */

/**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.
     *
     * @param   loader the class loader to define the proxy class
     * @param   interfaces the list of interfaces for the proxy class
     *          to implement
     * @param   h the invocation handler to dispatch method invocations to
     * @return  a proxy instance with the specified invocation handler of a
     *          proxy class that is defined by the specified class loader
     *          and that implements the specified interfaces
     */
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {..........}

public interface Subject {
    void getNews();
    void hello(String str);
}

public class RealSubject implements Subject {
    @Override
    public void getNews() {
        System.out.println("北京要实行垃圾分类了");
    }

    @Override
    public void hello(String str) {
        System.out.println("hello:" + str);
    }
}

public class ProxyFactory{
    //真实对象
    private Object realObj;

    public ProxyFactory(Object realObj){
        this.realObj = realObj;
    }

    /*获取代理对象*/
    public Object getProxyInstance(){
        Object proxyInstance = Proxy.newProxyInstance(realObj.getClass().getClassLoader(), realObj.getClass().getInterfaces(), new InvocationHandleImpl());
        System.out.println("获取到的代理对象：" + proxyInstance.getClass().getName());
        return proxyInstance;
    }

    //InvocationHandler的实现
    class InvocationHandleImpl implements InvocationHandler{

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("invoke中的代理对象：" + proxy.getClass().getName());
            //在代理真实对象之前添加一些自己的操作
            System.out.println("===before");
            System.out.println("method:" + method);
            Object invokeResult = method.invoke(realObj, args);
            //在代理真实对象之后添加一些自己的操作
            System.out.println("===after");
            return invokeResult;
        }
    }

}

public class Test {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        ProxyFactory proxyFactory = new ProxyFactory(realSubject);
        //获取代理对象
        Subject proxyInstance = (Subject) proxyFactory.getProxyInstance();
        //基于代理对象的方法调用
        proxyInstance.getNews();
        proxyInstance.hello("动态代理");
    }
}

获取到的代理对象：com.sun.proxy.$Proxy0
invoke中的代理对象：com.sun.proxy.$Proxy0
===before
method:public abstract void com.hy.spring.service.Subject.getNews()
北京要实行垃圾分类了
===after
invoke中的代理对象：com.sun.proxy.$Proxy0
===before
method:public abstract void com.hy.spring.service.Subject.hello(java.lang.String)
hello:动态代理
===after

method:public abstract void com.hy.spring.service.Subject.getNews()
method:public abstract void com.hy.spring.service.Subject.hello(java.lang.String)