Java中的动态代理技术可以动态的创建并且动态处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器,它的工作是揭示调用的类型并确定相应的策略.
下面是实现动态代理技术的步骤：

• 1.编写代理类这个类实现InvacationHandler接口
• 2.写一个公共接口
• 3.编写实际类实现这个公共接口
• 4.使用Proxy.newProxyInstance()静态方法得到代理类引用 proxy

1. 写一个代理类实现InvacationHandler接口

package com.minglangx.proxy;

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

　　* @ClassName: MethodSelector
　　* @Description: 代理器
　　* @author minglangx
　　* @date 2017年5月1日 下午3:02:16
　　*
 */
public class MethodSelector implements InvocationHandler{
    

    private Object proxied;
    
    public MethodSelector(Object proxied) {
        this.proxied = proxied;
    }
    
    
   /**
     * proxy被代理的对象
     * Method 代理所调用的方法
     * args[] 代理对象调用方法中参数组成的集合
     * 该方法实现对接口的调用被重定向为对代理的调用
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
        
        if(method.getName().equals("interesting")) {
            System.out.println("Proxy detected the interesting method");
        }
        
        return method.invoke(proxied, args);
    }

}

2. 写一个公共接口

package com.minglangx.proxy;
/**
 * 
　　* @ClassName: SomeMethods
　　* @Description: 公共接口方法
　　* @author minglangx
　　* @date 2017年5月1日 下午4:26:44
　　*
 */
public interface SomeMethods {

    void boring1();
    void boring2();
    void interesting(String arg);
    void boring3();
}

3.实现类实现这个接口

package com.minglangx.proxy;

/**
 * @ClassName: Implementation
 * @Description: 实际对象类
 * @author minglangx
 * @date 2017年5月1日 下午3:10:58
 */
public class Implementation implements SomeMethods {

    @Override
    public void boring1() {
        System.out.println("调用了实际对象----boring1");

    }

    @Override
    public void boring3() {
        System.out.println("调用了实际对象----boring3");
    }

    @Override
    public void interesting(String arg) {
        System.out.println("调用了实际对象的方法interesting输出--" + arg);
    }

    @Override
    public void boring2() {
        System.out.println("调用了实际对象----boring2");

    }

}

4.测试动态代理

package com.minglangx.proxy;

import java.lang.reflect.Proxy;

/**
 * 
 * 
 * @ClassName: SelectingMethods
 * 
 * @Description: 测试动态代理类
 * 
 * @author minglangx
 * 
 * @date 2017年5月1日 下午3:14:50
 *
 * 
 * 
 * 
 * 
 */
public class SelectingMethods {

    public static void main(String[] args) {
        /*
         * 这里使用Proxy.newProxyInstance()可以创建动态代理 方法接收3个参数
         * （一个类加载器、一个实现InvacationHandler接口的实现类、 实际对象的引用
         */
        SomeMethods proxy =(SomeMethods) Proxy.newProxyInstance(
                SomeMethods.class.getClassLoader(),
                new Class[] { SomeMethods.class }, 
                new MethodSelector(new Implementation()));//这里传入实际的对象必须制定传入参数类型
        proxy.boring1();
        proxy.boring2();
        proxy.interesting("bonbo");
        proxy.boring3();
    
    }

}