• Spring事务Transactional和动态代理(一)-JDK代理实现


    系列文章索引:

    1. Spring事务Transactional和动态代理(一)-JDK代理实现
    2. Spring事务Transactional和动态代理(二)-cglib动态代理
    3. Spring事务Transactional和动态代理(三)-事务失效的场景

    什么是代理

    理设计模式提供了对目标对象的间接访问方式,能力模式能够解耦合并且便于扩展目标的功能。

    在现实生活这,我们消费者如果要去购买一杯牛奶的时候,并不是直接去找牛奶厂商购买,而是在便利店或者超市购买(零售商);超市进货的时候也通常不是直接找牛奶厂商,而是找市级代理(渠道经销商),市级代理再找省级代理(代理商),省级代理从牛奶生产商(厂商)提货。
    如下图,虽然通过层层代理,一杯牛奶的价格会有增加,但是用户省却了时间(用户不能跑到内蒙去买牛奶)。

    静态代理

    静态代理的实现比较简单,代理类通过实现与目标对象相同的接口,并在类中维护一个代理对象。通过构造器塞入目标对象,赋值给代理对象,进而执行代理对象实现的接口方法

    public interface Person {
        void eat();
    }
    
    public class Child implements Person {
        @Override
        public void eat() {
            System.out.println("A Child eats something");
        }
    }
    
    
    public class StaticProxyDemo {
    
        public static void main(String[] args) {
            Person person = new Child();
            person.eat();
        }
    }
    

    代理类如下:

    public class PersonProxy {
       private Person person;
    
       public PersonProxy(Person person){
           this.person = person;
       }
    
       private void beforeExecute(){
           System.out.println("before");
       }
    
       public void execute(){
           beforeExecute();
           person.eat();
           afterExecute();
       }
    
        private void afterExecute(){
            System.out.println("after");
        }
    
    
        public static void main(String[] args) {
            PersonProxy personProxy = new PersonProxy(new Child());
            personProxy.execute();
        }
    }
    
    

    静态代理的优点:

    这样可以通过PersonProxy来操作目标对象Person,且在不修改Person对象的条件下能够对目标对象进行beforeExecute()和afterExecute()的拦截操作,这样就达到了解耦合和扩展目标对象的功能。

    静态代理的缺点:

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

    动态代理的实现

    JDK的动态代理是基于java.lang.reflect.Proxy实现的InvocationHandler接口
    增加Proxy对象,需要实现InvocationHandler,可以看到DynamicPersonProxy类并没有实现Person接口或者继承Person接口的子类,DynamicPersonProxy类是完全与Person松耦合

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class DynamicPersonProxy implements InvocationHandler {
    
        private Object target;
    
        public DynamicPersonProxy(Object target){
            this.target = target;
        }
    
        public <T> T getProxy(){
            return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
        }
    
        private void beforeInvoke(){
            System.out.println("before");
        }
    
        private void afterInvoke(){
            System.out.println("after");
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            beforeInvoke();
            Object result = method.invoke(target,args);
            afterInvoke();
            return result;
        }
    }
    

    测试类如下:

    public class DynamicProxyTest{
    
        public static void main(String[] args) {
    //        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            Person person = new Child();
            DynamicPersonProxy dynamicPersonProxy = new DynamicPersonProxy(person);
            Person proxyPerson = (Person) dynamicPersonProxy.getProxy();
            proxyPerson.eat();
    }
    
    }
    
    //输出如下:
    before
    A Child eats something
    after
    

    动态代理的优点:

    代理对象无需实现接口,接口增加方法也就无需再修改代理对象

    动态代理的缺点:

    目标对象一定要实现接口,否则无法使用JDK动态代理

    动态代理的原理

    动态代理的核心流程是:

    1. 为接口创建代理类的字节码文件
    2. 使用ClassLoader将字节码文件加载到JVM
    3. 创建代理类实例对象
    4. 执行对象的目标方法

    JDK Proxy源码分析

    下面从源码的角度来看一下动态代理的实现原理
    核心方法Proxy.newProxyInstance源码如下:

        @CallerSensitive
        public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        {
            //InvocationHandler不能为空
            Objects.requireNonNull(h);
            //clone接口
            final Class<?>[] intfs = interfaces.clone();
            final SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
            }
    
            //首先从缓存查找是否有代理类,没有就生成一个
            Class<?> cl = getProxyClass0(loader, intfs);
    
            /*
             * 通过InvocationHandler调用目标类的构造函数
             */
            try {
                if (sm != null) {
                    checkNewProxyPermission(Reflection.getCallerClass(), cl);
                }
                //constructorParams是指指定代理类的构造函数类型
                final Constructor<?> cons = cl.getConstructor(constructorParams);
                final InvocationHandler ih = h;
                //如果构造函数不是public修饰,修改
                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);
            }
        }
    

    其中查找Proxy类的源码如下:

        private static Class<?> getProxyClass0(ClassLoader loader,
                                               Class<?>... interfaces) {
            //长度检查
            if (interfaces.length > 65535) {
                throw new IllegalArgumentException("interface limit exceeded");
            }
             
            //调用了下面的WeakCache<K, P, V>.get(K key, P parameter)方法,loader作为key,interfaces作为parameter参数
            //定义如下:proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory())
            return proxyClassCache.get(loader, interfaces);
        }
    
    
       //首先当前key(也就是上面的ClassLoader)已经加载存在,就直接从缓存中返回
       //如果不存在,就会通过ProxyClassFactory来创建代理对象
       public V get(K key, P parameter) {
            Objects.requireNonNull(parameter);
    
            expungeStaleEntries();
             //根据key的hash值和一个ReferenceQueue来构造
            Object cacheKey = CacheKey.valueOf(key, refQueue);
    
            // 从map中取出cacheKey的值
            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;
                }
            }
    
            Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
            Supplier<V> supplier = valuesMap.get(subKey);
            Factory factory = null;
    
            while (true) {
                if (supplier != null) {
                    // supplier可能是Factory或者CacheValue<V>
                    V value = supplier.get();
                    if (value != null) {
                        return value;
                    }
                }
                // 缓存中没有supplier,同时supplier中没有
                // 懒加载的方式创建一个Factory
                if (factory == null) {
                    factory = new Factory(key, parameter, subKey, valuesMap);
                }
    
                if (supplier == null) {
                    supplier = valuesMap.putIfAbsent(subKey, factory);
                    if (supplier == null) {
                        // 安装 Factory
                        supplier = factory;
                    }
                } else {
                    if (valuesMap.replace(subKey, supplier, factory)) {
                        supplier = factory;
                    } else {
                        supplier = valuesMap.get(subKey);
                    }
                }
            }
        }
    
    

    再看一下上面提到的ProxyClassFactory是一个 工厂方法,是一个静态final类,实现了BiFunction接口,其中只有一个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) {
                    /*
                     * 校验当前类加载器ClassLoader解析到的名称和定义的名称是否相同 
                     */
                    Class<?> interfaceClass = null;
                    try {
                        interfaceClass = Class.forName(intf.getName(), false, loader);
                    } catch (ClassNotFoundException e) {
                    }
                    if (interfaceClass != intf) {
                        throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                    }
                    /*
                     * 校验是否是接口类型,这也就是为什么JDK动态代理只能基于接口
                     */
                    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());
                    }
                }
    
               // 代理对象的目录
                String proxyPkg = null;     
                int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
    
                .....
    
                /*
                 * 生成指定Proxy代理对象的字节码
                 */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
                try {
                    //调用的native方法
                    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    /*
                     * 生成的代理类有bug
                     */
                    throw new IllegalArgumentException(e.toString());
                }
            }
    
    }
    
    

    Proxy代理字节码生成分析

    去掉DynamicProxyTest类中的注释

    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    

    这样就可以看到JDK生成的class文件。所生成的$Proxy0特性如下:

    1. 继承了Proxy,实现了目标接口Person。因为Java不允许多重继承,这就限制了:使用JDK代理不能是普通类或者抽象类,只能是接口类型
    2. 只有一个InvocationHandler参数的构造函数,所以代理类必须继承InvocationHandler接口
    3. 生成了同名的eat()方法,且调用了InvocationHandler的invoke方法
    4. 使用静态代码块初始化Object类的equals,toString和hashCode方法,还有Person接口的eat方法

    如上示例反编译所生成的class文件内容如下:

    package com.sun.proxy;
    
    import com.randy.dynamicproxy.jdk.interfaces.Person;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    
    public final class $Proxy0 extends Proxy implements Person {
        private static Method m1;
        private static Method m3;
        private static Method m2;
        private static Method m0;
    
        public $Proxy0(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 eat() throws  {
            try {
                super.h.invoke(this, m3, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        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.randy.dynamicproxy.jdk.interfaces.Person").getMethod("eat");
                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());
            }
        }
    }
    
  • 相关阅读:
    CF1042E Vasya and Magic Matrix
    Luogu 4868 Preprefix sum
    CF1042F Leaf Sets
    CF1041F Ray in the tube
    【Luogu】P1410子序列(DP)
    【Luogu】P1383高级打字机
    【Luogu】P1681最大正方形2(异或运算,DP)
    【Luogu】P1122最大子树和(DFS,树上DP)
    【Luogu】P2258子矩阵(状态压缩,DP)
    【Luogu】P2158仪仗队(欧拉函数)
  • 原文地址:https://www.cnblogs.com/qizhelongdeyang/p/12411576.html
Copyright © 2020-2023  润新知