Java中的动态代理--JDK动态代理

       首先，我们用一个通俗的例子来理解一下代理。假设有一位明星，他会唱歌和跳舞。那么在这位明星成名之前，我们可以直接找这位明星唱歌和跳舞。但是他出名之后，肯定会找一个经济人，我们再想听这位明星唱歌或者看他跳舞，就只能先找到他的经济人，经纪人可能会向我们收费，然后再安排这位明星唱歌或者跳舞。这个经济人扮演的角色，其实就和我们今天要讲的代理特别相似。代理的目的是拦截对真实业务对象的直接访问。

    下面，我们将使用Java代码来实现动态代理。

（1）首先创建一个人类的接口

package com.sunyb.proxy;/** * 人类的接口 */public interface Person {    /**     * 唱歌方法     * @param songName 歌名     */    public abstract void sing(String songName);    /**     * 跳舞方法     * @param name 舞蹈名称     * @return     */    public abstract String dance(String name);}

（2）然后创建一个明星类，并实现人类接口

package com.sunyb.proxy;/** * 明星类 * @author sunyb * @since 2016-05-21 * @version 1.0 */public class PopStar implements Person {    @Override    public void sing(String songName) {        System.out.println("PopStar is singing " + songName);    }    @Override    public String dance(String name) {        System.out.println("PopStar is dancing " + name);        return "谢谢你们！";    }}

（3）创建代理对象类

package com.sunyb.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;/** * 明星类的代理类 * @author sunyb * @since 2016-05-21 * @version 1.0 */public class PopStarProxy {    public static Object createProxy(final Object targetObject){        /**         * @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         */        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),                targetObject.getClass().getInterfaces(),                new InvocationHandler() {                    /**                     * @param proxy the proxy instance that the method was invoked on                     * @param method 被调用的方法                     * @param args 被调用方法上的参数                     * @return                     * @throws Throwable                     */                    @Override                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        Object result = null;                        System.out.println("我是代理对象，方法调用前...");                        String methodName = method.getName();                        switch (methodName){                            case "sing":                                System.out.println("唱歌前，需要先付8000元...");                                break;                            case "dance":                                System.out.println("跳舞前，需要先付12000元...");                                break;                            default:                                System.out.println("对不起，该明星没有这项技能！");                                break;                        }                        //开始调用真实对象的方法                        /**                         * 通过反射的方式调用method方法                         * targetObject 是被反射的对象，也就是调用它的method方法                         * args是调用该方法时需要的参数                         */                        result = method.invoke(targetObject, args);                        System.out.println("我是代理对象，方法调用后...");                        return result;                    }                });    }}

（4）编写测试程序

----->唱歌

PopStar popStar = new PopStar();        Person person = (Person) PopStarProxy.createProxy(popStar);        person.sing("南山南");

---结果

我是代理对象，方法调用前...
唱歌前，需要先付8000元...
PopStar is singing 南山南
我是代理对象，方法调用后...

--->跳舞

PopStar popStar = new PopStar();        Person person = (Person) PopStarProxy.createProxy(popStar);        String result = person.dance("天鹅湖");        System.out.println(result);

--结果

我是代理对象，方法调用前...
跳舞前，需要先付12000元...
PopStar is dancing 天鹅湖
我是代理对象，方法调用后...
谢谢你们！

（5）当业务逻辑复杂时可以像上面这么写，但是当业务简单时，不需要单独创建一个代理类，可以直接这么写：

final PopStar popStar = new PopStar();        Person person = (Person) Proxy.newProxyInstance(popStar.getClass().getClassLoader(),                popStar.getClass().getInterfaces(), new InvocationHandler() {                    @Override                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        System.out.println("唱歌或者跳舞前，需要先给8000块!");                        return method.invoke(popStar, args);                    }                });        String result = person.dance("钢管舞");        System.out.println(result);