Java静态代理和动态代理

Java静态代理和动态代理

一、概述

代理是一种模式，提供了对目标对象的间接访问方式，即通过代理访问目标对象。如此便于在目标实现的基础上增加额外的功能操作，前拦截，后拦截等，以满足自身的业务需求，同时代理模式便于扩展目标对象功能的特点也为多人所用。

二、图形描述

三、静态代理

静态代理的实现比较简单，代理类通过实现与目标对象相同的接口，并在类中维护一个代理对象。通过构造器塞入目标对象，赋值给代理对象，进而执行代理对象实现的接口方法，并实现前拦截，后拦截等所需的业务功能。

/**
 * 目标对象实现的接口
 * @author jiyukai
 */
public interface BussinessInterface {
 
    void execute();
}
 
/**
 * 目标对象实现类
 * @author jiyukai
 */
public class Bussiness implements BussinessInterface{
 
    @Override
    public void execute() {
        System.out.println("执行业务逻辑...");
    }
}
 
/**
 * 代理类，通过实现与目标对象相同的接口
 * 并维护一个代理对象，通过构造器传入实际目标对象并赋值
 * 执行代理对象实现的接口方法，实现对目标对象实现的干预
 * @author jiyukai
 */
public class BussinessProxy implements BussinessInterface{
     
    private BussinessInterface bussinessImpl;
     
    public BussinessProxy(BussinessInterface bussinessImpl) {
        this.bussinessImpl = bussinessImpl;
    }
     
    @Override
    public void execute() {
        System.out.println("前拦截...");
        bussinessImpl.execute();
        System.out.println("后拦截...");
    }
}

静态代理的总结

优点：可以做到不对目标对象进行修改的前提下，对目标对象进行功能的扩展和拦截。

缺点：因为代理对象，需要实现与目标对象一样的接口，会导致代理类十分繁多，不易维护，同时一旦接口增加方法，则目标对象和代理类都需要维护。

四、动态代理
　　
　　动态代理是指动态的在内存中构建代理对象（需要我们制定要代理的目标对象实现的接口类型）。

1. 动态代理的分类：基于接口的动态代理（JDK官方）和基于子类的动态代理（cglib）
2. 具体演示
   （1）基于接口的动态代理

package com.renjing.proxy;

/**
 * 此为被代理类的接口
 * 一个经纪公司的要求:
 * 能做基本的表演和危险的表演
 */

public interface IActor {
    /**
     * 基本的演出
     *
     */
    public void basicAct(float money);

    /**
     * 危险演出
     */
    public void dangerAct(float money);
}

package com.renjing.proxy;
/**
 * 此为实际的被代理类
 */
public class Actor implements IActor {

    /**
     * 基本演出
     * @param money
     */
    @Override
    public void basicAct(float money) {
        System.out.println("拿到钱，开始基本的表演："+money);
    }

    /**
     * 危险演出
     * @param money
     */
    @Override
    public void dangerAct(float money) {
        System.out.println("拿到钱，开始危险的表演："+money);
    }
}

package com.renjing.proxy;

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

public class Client {
    public static void main(String[] args) {
        //一个剧组找演员
        Actor actor = new Actor();//直接

        /**
         * 代理：间接。
         * 获取代理对象：
         *  要求：被代理类最少实现一个接口。但是代理类无需实现任何接口。
         * 创建的方式：Proxy.newProxyInstance(三个参数)
         * 参数含义：
         * ClassLoader：和被代理对象使用相同的类加载器。
         * Interfaces：和被代理对象具有相同的行为。实现相同的接口。
         * InvocationHandler：如何代理。
         *      策略模式：使用场景是：
         *          数据有了，目的明确。
         *          达成目标的过程，就是策略。
         */
        IActor proxyActor = (IActor) Proxy.newProxyInstance(actor.getClass().getClassLoader(), actor.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * 执行被代理对象的任何方法，都会经过该方法。
                 * 此方法有拦截的功能。
                 *  参数：
                 *      proxy：代理对象的引用。不一定每次都用得到。
                 *      method：当前执行的方法对象。
                 *      args：执行方法所需的参数。
                 *  返回值：
                 *      当前执行方法的返回值。
                 */
                String name = method.getName();
                Float money = (Float)args[0];
                Object rtValue = null;
                //每个经纪公司对不同演出收费不一样，此处开始判断
                if ("basicAct".equals(name)) {
                    //基本演出
                    if (money > 2000) {
                        //看上去剧组是给了 8000，实际到演员手里只有 4000
                        //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                        rtValue = method.invoke(actor, money/2);
                    }
                }
                if ("dangerAct".equals(name)) {
                    //基本演出
                    if (money > 5000) {
                        //看上去898剧组是给了 8000，实际到演员手里只有 4000
                        //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                        rtValue = method.invoke(actor, money/2);
                    }
                }
                return rtValue;
            }
        });
        //没有经济公司的时候，直接找演员。
        actor.basicAct(100f);
        actor.dangerAct(500f);

        //剧组无法直接联系演员，而是由经纪公司找的演员
        proxyActor.basicAct(8000f);
        proxyActor.dangerAct(50000f);
    }
}

（2）基于子类的动态代理

package com.renjing.cglib;
/**
 * 此为被代理类：不能为最终类
 */
public class Actor {
    /**
     * 基本演出
     * @param money
     */
    public void basicAct(float money) {
        System.out.println("CGLIB拿到钱，开始基本的表演："+money);
    }

    /**
     * 危险演出
     * @param money
     */
    public void dangerAct(float money) {
        System.out.println("CGLIB拿到钱，开始危险的表演："+money);
    }
}

package com.renjing.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class Client {
    public static void main(String[] args) {
        //一个剧组找演员
        final Actor actor = new Actor();//直接(注意在匿名内部类中只能引用final类型的外部变量)

        /**
         * 基于子类的动态代理
         *  要求：被代理的对象不能是最终类。
         *  用到的类：Enhancer
         *  用到的方法：create(Class,Callback)
         *  方法的参数：
         *      Class:被代理对象的字节码。
         *      Callback：如何代理。
         */
        Actor cglibActor = (Actor) Enhancer.create(actor.getClass(), new MethodInterceptor() {
            /**
             * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何方法进行增强。
             *
             * 参数：
             *      前三个和基于接口的动态代理是一样的。
             *      MethodProxy：当前执行方法的代理对象。
             *      返回值：当前执行方法的返回值。
             */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                String name = method.getName();
                Float money = (Float) args[0];
                Object rtValue = null;
                //每个经纪公司对不同演出收费不一样，此处开始判断
                if ("basicAct".equals(name)) {
                    //基本演出
                    if (money > 2000) {
                        //看上去剧组是给了 8000，实际到演员手里只有 4000
                        //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                        rtValue = method.invoke(actor, money / 2);
                    }
                }
                if ("dangerAct".equals(name)) {
                    //基本演出
                    if (money > 5000) {
                        //看上去898剧组是给了 8000，实际到演员手里只有 4000
                        //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                        rtValue = method.invoke(actor, money / 2);
                    }
                }
                return rtValue;
            }
        });
        cglibActor.basicAct(10000);
        cglibActor.dangerAct(100000);
    }
}

动态代理的总结

优点：代理对象无需实现接口，免去了编写很多代理类的烦恼，同时接口增加方法也无需再维护目标对象和代理对象，只需在事件处理器中添加对方法的判断即可。

缺点：代理对象不需要实现接口，但是目标对象一定要实现接口，否则无法使用JDK动态代理。

原文地址：https://www.cnblogs.com/jiyukai/p/6958744.html