静态代理

实现静态代理的前提：

1、代理类和被代理类实现了同一接口

2、被代理类需要实现具体继承接口中的方法

3、代理类调用的是具体类中的方法（也就是说代理类中需要接受一个被代理类的对象）

这里举的例子就是，供应商 - 微商 - 客户之间的代理

供应商/微商的接口：

public interface Seller {
    public void toSell();
}

供应商的实现类：

public class NormalSeller implements Seller{

    @Override
    public void toSell() {
        System.out.println("我是卖鞋的!!!");
    }
}

微商类的实现（这里体现的就是代理类）：

public class MicroSeller implements Seller {
    Seller normal = new NormalSeller();

    @Override
    public void toSell() {
        this.go();
        this.normal.toSell();
        this.againgo();
    }

    public void go(){
        System.out.println("瞧一瞧,看一看");
    }

    public void againgo(){
        System.out.println("要不继续看看？");
    }
}

这里Main如下：

public class Mymain {
    public static void main(String[] args){
        Seller testSeller = new MicroSeller();
        testSeller.toSell();
    }
}

那么以上是不是就通过静态代理，实现了微商类的代理类，因为我们在里面写了另外的两个方法go和againgo，通过这种静态代理模式，给了原本只有toSell方法就添加了两种方法，并且没有改变原来的类！

但是也有缺点：

1、要为每一个接口实现代理类，一旦接口增加方法，目标对象与代理对象都要维护。

这个缺点怎么理解？

比如现在又是一个，如果供应商需要回购不需要的鞋子的话，在接口中就需要添加一个buy的方法，那么被代理需要去实现，然后代理类也需要进行调用，导致了两个类都需要进行维护！

动态代理

动态代理的话，就可以帮助我们解决上面的问题！

动态代理和静态代理的唯一区别就在于：动态代理是动态生成的，省去为接口实现代理类的操作。

要使用动态代理的话，只需要将被代理类继承InvocationHandler接口，然后实现其中的方法invoke即可！

那么静态代理中的被代理类实现动态代理：

这里写的时候有个变动，就是之前说的代理类中需要接受一个被代理类的对象，现在这个被代理类的对象就作为代理类的构造函数的参数传入！

供应商/微商的接口：

public class NormalSeller implements Seller{

    @Override
    public void toSell() {
        System.out.println("我是卖鞋的!!!");
    }
}

供应商的实现类：

public class NormalSeller implements Seller{

    @Override
    public void toSell() {
        System.out.println("我是卖鞋的!!!");
    }
}

微商实现的类：

public class MicroSeller implements InvocationHandler {
    Object normal;

    public MicroSeller(Object normal){
        this.normal = normal;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("瞧一瞧，看一看!!!");

        if(method.getName().equals("toSell")){
            try {
                method.invoke(this.normal, args);
//                System.out.println("this is my toSell method!!!");
            }catch (Exception e){
                System.out.println(e);
                return null;
            }
        }
        System.out.println("要不继续看看???");
        return null;
    }
}

public class MyMain {
    public static void main(String[] args){
        Seller normal = new NormalSeller();
        InvocationHandler invocationHandler = new MicroSeller(normal);
        
        Seller microSeller = (Seller)Proxy.newProxyInstance(
                Seller.class.getClassLoader(),
                new Class[]{Seller.class},
                invocationHandler);

        microSeller.toSell();
    }
}

结果图如下：

继续讲，通过动态代理就可以方便的进行代理，就是将被代理类继续接口InvocationHandler，然后去实现InvocationHandler接口中的invoke方法，在invoke方法中进行我们要想代理的东西即可！

Proxy.newProxyInstance流程

那么继续思考，Proxy.newProxyInstance到底是怎么实现的，它为什么可以帮助我们实现自己想要实现的代理方法、语句等？

跟进去继续看newProxyInstance的源码实现（讲重点，主要自己看的太吃力了）：

   public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h); //判断InvocationHandler实例h存在不存在，不存在则直接抛出异常

        final Class<?>[] intfs = interfaces.clone(); //撒子玩意，盲猜 返回了Interface的class实例
        final SecurityManager sm = System.getSecurityManager(); //得到系统管理器的实例
        if (sm != null) { //判断系统管理器实例是否获得
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs); //检查权限，看了下getProxyClass0里面的注释，如果调用getProxyClass0方法就必须判断权限checkProxyAccess
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs); //获取代理类，里面是return proxyClassCache.get(loader, interfaces); ，这里注释有说明，
//如果你传入的loader定义的代理类有实现指定的接口的话，就通过WeakCache类的缓存中返回一个代理类，如果不是，就通过ProxyClassFactory来生成一个代理类

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl); //大概就是权限检测
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams); //获取实现InvocationHandler接口的类的构造函数
            final InvocationHandler ih = h; //接受了参数InvocationHandler h
            if (!Modifier.isPublic(cl.getModifiers())) { //判断该类的修饰符是否为public属性
                AccessController.doPrivileged(new PrivilegedAction<Void>() { //如果不是的话则改为public
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h}); //通过cons构造器创建一个对应的Class实例的对象
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

这里继续看getProxyClass0中的方法：

如下显示，通过注释可以知道，如果传入的加载器定义的代理类实现给定的接口存在，这将简单地返回缓存副本，否则就使用ProxyClassFactory去生成这个代理类

    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

ProxyClassFactory为如下：

private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // prefix for all proxy class names
    private static final String proxyClassNamePrefix = "$Proxy"; //代理类对象的前缀名 $Proxy


    // next number to use for generation of unique proxy class names 
    private static final AtomicLong nextUniqueNumber = new AtomicLong(); //用于生成唯一代理类名的下一个编号


    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            /*
             * Verify that the class loader resolves the name of this
             * interface to the same Class object.
             */
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader); //通过指定loader加载器生成指定类，如果没有找到指定的类则抛出异常
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) { //如果加载的interfaceClass跟intf不一致则抛出异常
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            /*
             * Verify that the Class object actually represents an
             * interface.
             */
            if (!interfaceClass.isInterface()) {//验证类对象是否表示同一个接口
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            /*
             * Verify that this interface is not a duplicate.
             */
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { //判断接口是否是重复的
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }


        String proxyPkg = null;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;


        /*
         * Record the package of a non-public proxy interface so that the
         * proxy class will be defined in the same package.  Verify that
         * all non-public proxy interfaces are in the same package.
         */
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
            // if no non-public proxy interfaces, use com.sun.proxy package 
            proxyPkg = ReflectUtil.PROXY_PACKAGE + "."; // "com.sun.proxy." 字符串进行拼接
        }

        /*
         * Choose a name for the proxy class to generate.
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num; // 拼接要生成代理类的名称， com.sun.proxy.$Proxy0/1/2/3

        /*
         * Generate the specified proxy class.
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); //获取要生成类class的字节码

        try {
            return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); //通过反射defineClass0生成一个指定的Class类实例
        } catch (ClassFormatError e) {
            /*
             * A ClassFormatError here means that (barring bugs in the
             * proxy class generation code) there was some other
             * invalid aspect of the arguments supplied to the proxy
             * class creation (such as virtual machine limitations
             * exceeded).
             */
            throw new IllegalArgumentException(e.toString());
        }
    }
}

运行如下代码：

public class MyMain {
    public static void main(String[] args){
        Seller normal = new NormalSeller();
        InvocationHandler invocationHandler = new MicroSeller(normal);

        Seller microSeller = (Seller)Proxy.newProxyInstance(
                Seller.class.getClassLoader(),
                new Class[]{Seller.class},
                invocationHandler);


        microSeller.toSell();

        System.out.println(microSeller.getClass().getName());

    }
}

最终获取的类名为如下显示：

那么其实也就是Proxy.newInstance()反射动态生成了一个对应的代理类返回，并且该类的名称还是com.sun.proxy.$Proxy0/1/2/3递增的！