Java动态代理浅析

什么是代理

代理模式也叫做委托模式,它是一种基本的设计模式,其作用是提供委派角色以控制对真实对象的访问

JDK代理实现

静态代理

典型的静态代理模式通常包含一下三类角色
1.抽象角色:它的作用是定义一组行为规范。抽象角色一般呈现为接口(或抽象类)
2.真实角色:也叫做被委托角色、被代理角色
3.代理角色:也叫做委托类、代理类根据上面代理的定义,代理角色也需要实现抽象角色所定义的行为(即代理类需要实现抽象角色所定义的接口),并且在实现接口方法的时候需要调用真实角色的相应方法

静态代理类依赖于真实类,对每一个真实类作代理都需要对应一个代理类,静态代理大量使用会导致类的急剧膨胀

动态代理

区别于静态代理在编译期确定代理类和真实类的关系并且生成代理类。动态代理则是在运行期利用JVM的反射机制生成代理类的字节码,并通过类加载器载入执生成代理对象

JDK动态代理

运行时借助Proxy工具类静态方法创实现了一组特定接口的代理类和对象,Proxy类是所有被创建的动态代理类的父类每一个动态代理对象都会与特定的invocationHandler对象绑定,对任意代理对象实现的接口方法的调用都会最终委派InvocationHandler#invoke方法

使用样例

// 定义抽象角色接口
public interface Subject {
    void sayHello(String name);
}

// 接口实现
public class RealSubject implements Subject {
    @Override
    public void sayHello(String name){
        System.out.println("hello, "+ name);
    }
}

// 编写调用处理类,实现invoke方法(实现业务逻辑的入口)
public class MyInvocationHandler implements InvocationHandler {
    private Subject subject;

    MyInvocationHandler(Subject subject){
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        //前置处理
        System.out.println("Before method invoke...");
        System.out.println("Method:" + method);

        Object obj = method.invoke(subject, args);

        //后置处理
        System.out.println("After method invoke...");
        
        return obj;
    }
}

// 测试方法
public class ProxyTest {

    public static void main(String[] args) {
        // 设置变量可以保存动态代理类,默认名称以 $Proxy0 格式命名
        System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        Subject realSubject = new RealSubject();

        MyInvocationHandler handler = new MyInvocationHandler(realSubject);

        Subject proxy = (Subject)Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(), handler);

        proxy.sayHello("kevin");

        // 保存JDK动态代理生成的代理类,类名保存为RealSubjectProxy
        generateClassFile(realSubject.getClass(), "RealSubjectProxy");

    }
    
    /**
     * 将根据类信息动态生成的二进制字节码保存到硬盘中,默认的是classes目录下
     * params: clazz 需要生成动态代理类的类
     * proxyName: 为动态生成的代理类的名称
     */
    private static void generateClassFile(Class clazz, String proxyName) {
        // 根据类信息和提供的代理类名称,生成字节码
        byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
        String paths = clazz.getResource(".").getPath();
        System.out.println(paths);
        FileOutputStream out = null;
        try {
            //保留到硬盘中
            out = new FileOutputStream(paths + proxyName + ".class");
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

运行结果

Before method invoke...
Method:public abstract void com.example.demo.proxy.Subject.sayHello(java.lang.String)
After method invoke...
/Users/yuhuizhou/Project/demo/target/classes/com/example/demo/proxy/

Process finished with exit code 0

从运行结果可以看出,对代理对象方法的调用最终委派到了MyInvocationHandler.invoke方法,打印出了调用信息。在测试方法中,设置了系统属性把生成的字节码保存到class文件。Proxy类生成的代理类如下

import com.example.demo.proxy.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class RealSubjectProxy extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public RealSubjectProxy(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.example.demo.proxy.Subject").getMethod("sayHello", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

可以看到RealSubjectProxy继承自Proxy且实现了Subject接口,它定义了4个方法m0,m1,m2,m3,其中方法m3是对Subject#sayHello实现,通过super.h.invoke(this, m3, new Object[]{var1}),最终将方法的实现逻辑委派给了InvocationHandler#invoke

源码分析

Proxy类对外提供了4个静态方法,分别为

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces);
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h);
public static boolean isProxyClass(Class<?> cl);
public static InvocationHandler getInvocationHandler(Object proxy);

newProxyInstance

通过给定类加载器和接口生成代理对象,并把对被代理对象方法调用分派至特定InvocationHandler

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        // 获取代理类
        Class<?> cl = getProxyClass0(loader, intfs);

        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            // 获取带参数InvocationHandler的构造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            
            // 反射创建代理对象
            return cons.newInstance(new Object[]{h});
        } 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);
        }
    }

getProxyClass

通过给定类加载器创建实现给定接口的代理类

   public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException {
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

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

        // 如果缓存包含给定类加载器创建并且实现了特定接口的代理类,则返回该代理类; 否则动态创建此代理类对象
        return proxyClassCache.get(loader, interfaces);
    }

代理类对象缓存WeakCache

WeakCache为二级缓存结构(key,sub-key)->(value)

public class Proxy implements java.io.Serializable {
     private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
}

WeakCache#get方法实现,入参key为类加载器,parameter为接口数组

public V get(K key, P parameter) {
        // 校验入参接口数组非空
        Objects.requireNonNull(parameter);

        expungeStaleEntries();
        //通过类加载器和弱引用队列构造弱引用实例cacheKey(CacheKey继承WeakReference)
        //类加载器作为被弱引用对象,垃圾回收时会被清除
        Object cacheKey = CacheKey.valueOf(key, refQueue);

        //为cacheKey初始化二级缓存valuesMap(懒加载实现)
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // 通过subKeyFactory#apply创建二级缓存键subKey, 并尝试通过subKey从valuesMap获取Supplier<V>(subKeyFactory为KeyFactory实例,KeyFactory是一个函数式接口BiFunction实现)
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // 此处supplier.get()会转至Factory#get方法
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            
            if (factory == null) {
                //二级缓存值(Supplier<V>实现)
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

keyFactory#apply方法,其中Key1,Key2和Key X为Proxy内部类,分别对应被代理类实现接口个数为1,2或者>=3时实现

private static final class KeyFactory
        implements BiFunction<ClassLoader, Class<?>[], Object>
    {
        @Override
        public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
            switch (interfaces.length) {
                case 1: return new Key1(interfaces[0]); // the most frequent
                case 2: return new Key2(interfaces[0], interfaces[1]);
                case 0: return key0;
                default: return new KeyX(interfaces);
            }
        }
    }

Factory#get方法

        @Override
        public synchronized V get() { // serialize access
            // re-check
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }
            
            V value = null;
            try {
                // 通过valueFactory#apply方法生成代理类$Proxy0(valueFactory为ProxyClassFactory实例,
                // ProxyClassFactory是一个函数式接口BiFunction实现)
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            
            assert value != null;

            // 设置生成的代理类对象为被若引用对象,方便其在下次垃圾回收时被清理释放空间
            CacheValue<V> cacheValue = new CacheValue<>(value);

            // put into reverseMap
            reverseMap.put(cacheValue, Boolean.TRUE);

            // try replacing us with CacheValue (this should always succeed)
            if (!valuesMap.replace(subKey, this, cacheValue)) {
                throw new AssertionError("Should not reach here");
            }

            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }
    }

ProxyClassFactory#apply方法

private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>>{
        
        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                
                Class<?> interfaceClass = null;
                try {
                    // 校验接口interfaces是由类加载器loader加载的或者由loader的上一级类加载器加载
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                
                // 校验参数interfaces是否都是接口
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                
                // 校验是否存在重复接口
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            // ...
            
            // 设置生成的代理类名字
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            // 生成特定的代理类
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

Cglib是什么,为什么需要字节增强

评论

暂无评论