精华内容
下载资源
问答
  • 2018-01-30 20:19:24

    转载自 http://blog.csdn.net/zhu_tianwei/article/details/40076391

    使用通过接口定义,或解析接口注解等完成相关功能,如mybatis的SqlSession.getMapper的实现

    1.接口定义

    [java]  view plain  copy
    1. package cn.proxy;  
    2.   
    3. public interface IHello {  
    4.     String say(String aa);  
    5. }  

    2.代理实现

    [java]  view plain  copy
    1. package cn.proxy;  
    2.   
    3. import java.lang.reflect.InvocationHandler;  
    4. import java.lang.reflect.Method;  
    5. import java.lang.reflect.Proxy;  
    6.   
    7. /** 
    8.  *  JDK动态代理代理类  
    9.  * 
    10.  */  
    11. @SuppressWarnings("unchecked")  
    12. public class FacadeProxy implements InvocationHandler {    
    13.     @Override    
    14.     public Object invoke(Object proxy, Method method, Object[] args)    
    15.             throws Throwable {    
    16.         System.out.println("接口方法调用开始");    
    17.         //执行方法    
    18.         System.out.println("method toGenericString:"+method.toGenericString());  
    19.         System.out.println("method name:"+method.getName());  
    20.         System.out.println("method args:"+(String)args[0]);  
    21.         System.out.println("接口方法调用结束");    
    22.         return "调用返回值";    
    23.     }    
    24.       
    25.     public static <T> T newMapperProxy(Class<T> mapperInterface) {  
    26.         ClassLoader classLoader = mapperInterface.getClassLoader();  
    27.         Class<?>[] interfaces = new Class[]{mapperInterface};  
    28.         FacadeProxy proxy = new FacadeProxy();  
    29.         return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);  
    30.       }  
    31. }  


    4.运行

    [java]  view plain  copy
    1. package cn.proxy;  
    2.   
    3. public class Test {  
    4.     public static void main(String[] args) {  
    5.         IHello hello = FacadeProxy.newMapperProxy(IHello.class);  
    6.         System.out.println(hello.say("hello world"));  
    7.     }  
    8. }  

    运行结果:

    [plain]  view plain  copy
    1. 接口方法调用开始  
    2. method toGenericString:public abstract java.lang.String cn.proxy.IHello.say(java.lang.String)  
    3. method name:say  
    4. method args:hello world  
    5. 接口方法调用结束  
    6. 调用返回值  

    更多相关内容
  • Java JDK 动态代理(AOP)使用及实现原理分析

    万次阅读 多人点赞 2019-05-08 21:28:06
    二、Java 动态代理类 三、JDK的动态代理怎么使用? 四、动态代理怎么实现的? 五、结论 一、什么是代理代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为...

    目录

    一、什么是代理?

    二、Java 动态代理类 

    三、JDK的动态代理怎么使用?

    四、动态代理怎么实现的?

    五、结论


    一、什么是代理?

    代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理。

    代理模式UML图:

    简单结构示意图:

    为了保持行为的一致性,代理类和委托类通常会实现相同的接口,所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层,能有效控制对委托类对象的直接访问,也可以很好地隐藏和保护委托类对象,同时也为实施不同控制策略预留了空间,从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

    二、Java 动态代理类 

    Java动态代理类位于java.lang.reflect包下,一般主要涉及到以下两个类:

    (1)Interface InvocationHandler:该接口中仅定义了一个方法

    public object invoke(Object obj,Method method, Object[] args)

    在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,args为该方法的参数数组。这个抽象方法在代理类中动态实现。

    (2)Proxy:该类即为动态代理类,其中主要包含以下内容:

    protected Proxy(InvocationHandler h):构造函数,用于给内部的h赋值。

    static Class getProxyClass (ClassLoaderloader, Class[] interfaces):获得一个代理类,其中loader是类装载器,interfaces是真实类所拥有的全部接口的数组。

    static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)返回代理类的一个实例,返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)

    所谓DynamicProxy是这样一种class:它是在运行时生成的class在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然,这个DynamicProxy其实就是一个Proxy,它不会替你作实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作

    在使用动态代理类时,我们必须实现InvocationHandler接口

    通过这种方式,被代理的对象(RealSubject)可以在运行时动态改变,需要控制的接口(Subject接口)可以在运行时改变,控制的方式(DynamicSubject)也可以动态改变,从而实现了非常灵活的动态代理关系。

    动态代理步骤
    1.创建一个实现接口InvocationHandler的类,它必须实现invoke方法
    2.创建被代理的类以及接口
    3.通过Proxy的静态方法
    newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理
    4.通过代理调用方法

    三、JDK的动态代理怎么使用?

    1、需要动态代理的接口:

    package jiankunking;
    
    /**
     * 需要动态代理的接口
     */
    public interface Subject
    {
        /**
         * 你好
         *
         * @param name
         * @return
         */
        public String SayHello(String name);
    
        /**
         * 再见
         *
         * @return
         */
        public String SayGoodBye();
    }

    2、需要代理的实际对象

    package jiankunking;
    
    /**
     * 实际对象
     */
    public class RealSubject implements Subject
    {
    
        /**
         * 你好
         *
         * @param name
         * @return
         */
        public String SayHello(String name)
        {
            return "hello " + name;
        }
    
        /**
         * 再见
         *
         * @return
         */
        public String SayGoodBye()
        {
            return " good bye ";
        }
    }

    3、调用处理器实现类(有木有感觉这里就是传说中的AOP啊)

    package jiankunking;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    
    /**
     * 调用处理器实现类
     * 每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象
     */
    public class InvocationHandlerImpl implements InvocationHandler
    {
    
        /**
         * 这个就是我们要代理的真实对象
         */
        private Object subject;
    
        /**
         * 构造方法,给我们要代理的真实对象赋初值
         *
         * @param subject
         */
        public InvocationHandlerImpl(Object subject)
        {
            this.subject = subject;
        }
    
        /**
         * 该方法负责集中处理动态代理类上的所有方法调用。
         * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
         *
         * @param proxy  代理类实例
         * @param method 被调用的方法对象
         * @param args   调用参数
         * @return
         * @throws Throwable
         */
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
        {
            //在代理真实对象前我们可以添加一些自己的操作
            System.out.println("在调用之前,我要干点啥呢?");
    
            System.out.println("Method:" + method);
    
            //当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
            Object returnValue = method.invoke(subject, args);
    
            //在代理真实对象后我们也可以添加一些自己的操作
            System.out.println("在调用之后,我要干点啥呢?");
    
            return returnValue;
        }
    }

    4、测试

    package jiankunking;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    /**
     * 动态代理演示
     */
    public class DynamicProxyDemonstration
    {
        public static void main(String[] args)
        {
            //代理的真实对象
            Subject realSubject = new RealSubject();
            
            /**
             * InvocationHandlerImpl 实现了 InvocationHandler 接口,并能实现方法调用从代理类到委托类的分派转发
             * 其内部通常包含指向委托类实例的引用,用于真正执行分派转发过来的方法调用.
             * 即:要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法
             */
            InvocationHandler handler = new InvocationHandlerImpl(realSubject);
    
            ClassLoader loader = realSubject.getClass().getClassLoader();
            Class[] interfaces = realSubject.getClass().getInterfaces();
            /**
             * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
             */
            Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);
    
            System.out.println("动态代理对象的类型:"+subject.getClass().getName());
    
            String hello = subject.SayHello("jiankunking");
            System.out.println(hello);
    //        String goodbye = subject.SayGoodBye();
    //        System.out.println(goodbye);
        }
    
    }

    5、输出结果如下:

    演示demo下载地址:javajdk动态代理演示demo_jdk动态代理-Java代码类资源-CSDN下载

    四、动态代理怎么实现的?

    从使用代码中可以看出,关键点在:

    Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);

    通过跟踪提示代码可以看出:当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用。

    也就是说,当代码执行到:

    subject.SayHello("jiankunking")这句话时,会自动调用InvocationHandlerImpl的invoke方法。这是为啥呢?

    ==============横线之间的是代码跟分析的过程,不想看的朋友可以直接看结论===================

    以下代码来自:JDK1.8.0_92

    既然生成代理对象是用的Proxy类的静态方newProxyInstance,那么我们就去它的源码里看一下它到底都做了些什么? 

    /**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.
     *
     * <p>{@code Proxy.newProxyInstance} throws
     * {@code IllegalArgumentException} for the same reasons that
     * {@code Proxy.getProxyClass} does.
     *
     * @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
     * @throws  IllegalArgumentException if any of the restrictions on the
     *          parameters that may be passed to {@code getProxyClass}
     *          are violated
     * @throws  SecurityException if a security manager, <em>s</em>, is present
     *          and any of the following conditions is met:
     *          <ul>
     *          <li> the given {@code loader} is {@code null} and
     *               the caller's class loader is not {@code null} and the
     *               invocation of {@link SecurityManager#checkPermission
     *               s.checkPermission} with
     *               {@code RuntimePermission("getClassLoader")} permission
     *               denies access;</li>
     *          <li> for each proxy interface, {@code intf},
     *               the caller's class loader is not the same as or an
     *               ancestor of the class loader for {@code intf} and
     *               invocation of {@link SecurityManager#checkPackageAccess
     *               s.checkPackageAccess()} denies access to {@code intf};</li>
     *          <li> any of the given proxy interfaces is non-public and the
     *               caller class is not in the same {@linkplain Package runtime package}
     *               as the non-public interface and the invocation of
     *               {@link SecurityManager#checkPermission s.checkPermission} with
     *               {@code ReflectPermission("newProxyInPackage.{package name}")}
     *               permission denies access.</li>
     *          </ul>
     * @throws  NullPointerException if the {@code interfaces} array
     *          argument or any of its elements are {@code null}, or
     *          if the invocation handler, {@code h}, is
     *          {@code null}
     */
    @CallerSensitive 
    public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        {
    		//检查h 不为空,否则抛异常
            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);
                }
    			//获取代理对象的构造方法(也就是$Proxy0(InvocationHandler h)) 
                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;
                        }
                    });
                }
    			//生成代理类的实例并把InvocationHandlerImpl的实例传给它的构造方法
                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);
            }
        }

    我们再进去getProxyClass0方法看一下:

     /**
         * Generate a proxy class.  Must call the checkProxyAccess method
         * to perform permission checks before calling this.
         */
        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);
        }

    真相还是没有来到,继续,看一下 proxyClassCache

    /**
         * a cache of proxy classes
         */
        private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
            proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

    奥,原来用了一下缓存啊

    那么它对应的get方法啥样呢?

     /**
         * Look-up the value through the cache. This always evaluates the
         * {@code subKeyFactory} function and optionally evaluates
         * {@code valueFactory} function if there is no entry in the cache for given
         * pair of (key, subKey) or the entry has already been cleared.
         *
         * @param key       possibly null key
         * @param parameter parameter used together with key to create sub-key and
         *                  value (should not be null)
         * @return the cached value (never null)
         * @throws NullPointerException if {@code parameter} passed in or
         *                              {@code sub-key} calculated by
         *                              {@code subKeyFactory} or {@code value}
         *                              calculated by {@code valueFactory} is null.
         */
        public V get(K key, P parameter) {
            Objects.requireNonNull(parameter);
    
            expungeStaleEntries();
    
            Object cacheKey = CacheKey.valueOf(key, refQueue);
    
            // lazily install the 2nd level valuesMap for the particular cacheKey
            ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
            if (valuesMap == null) {
    			//putIfAbsent这个方法在key不存在的时候加入一个值,如果key存在就不放入
                ConcurrentMap<Object, Supplier<V>> oldValuesMap
                    = map.putIfAbsent(cacheKey,
                                      valuesMap = new ConcurrentHashMap<>());
                if (oldValuesMap != null) {
                    valuesMap = oldValuesMap;
                }
            }
    
            // create subKey and retrieve the possible Supplier<V> stored by that
            // subKey from valuesMap
            Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
            Supplier<V> supplier = valuesMap.get(subKey);
            Factory factory = null;
    
            while (true) {
                if (supplier != null) {
                    // supplier might be a Factory or a CacheValue<V> instance
                    V value = supplier.get();
                    if (value != null) {
                        return value;
                    }
                }
                // else no supplier in cache
                // or a supplier that returned null (could be a cleared CacheValue
                // or a Factory that wasn't successful in installing the CacheValue)
    
                // lazily construct a Factory
                if (factory == null) {
                    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);
                    }
                }
            }
        }

    我们可以看到它调用了 supplier.get(); 获取动态代理类,其中supplier是Factory,这个类定义在WeakCach的内部。

    来瞅瞅,get里面又做了什么?

     public synchronized V get() { // serialize access
                // re-check
                Supplier<V> supplier = valuesMap.get(subKey);
                if (supplier != this) {
                    // something changed while we were waiting:
                    // might be that we were replaced by a CacheValue
                    // or were removed because of failure ->
                    // return null to signal WeakCache.get() to retry
                    // the loop
                    return null;
                }
                // else still us (supplier == this)
    
                // create new value
                V value = null;
                try {
                    value = Objects.requireNonNull(valueFactory.apply(key, parameter));
                } finally {
                    if (value == null) { // remove us on failure
                        valuesMap.remove(subKey, this);
                    }
                }
                // the only path to reach here is with non-null value
                assert value != null;
    
                // wrap value with CacheValue (WeakReference)
                CacheValue<V> cacheValue = new CacheValue<>(value);
    
                // try replacing us with CacheValue (this should always succeed)
                if (valuesMap.replace(subKey, this, cacheValue)) {
                    // put also in reverseMap
                    reverseMap.put(cacheValue, Boolean.TRUE);
                } else {
                    throw new AssertionError("Should not reach here");
                }
    
                // successfully replaced us with new CacheValue -> return the value
                // wrapped by it
                return value;
            }
        }

    发现重点还是木有出现,但我们可以看到它调用了valueFactory.apply(key, parameter)方法:

     /**
         * A factory function that generates, defines and returns the proxy class given
         * the ClassLoader and array of interfaces.
         */
        private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>
        {
            // prefix for all proxy class names
            private static final String proxyClassNamePrefix = "$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);
                    } catch (ClassNotFoundException e) {
                    }
                    if (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 + ".";
                }
    
                /*
                 * Choose a name for the proxy class to generate.
                 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
    
                /*
                 * Generate the specified proxy class.
                 */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
                try {
                    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);
                } 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());
                }
            }
        }

    通过看代码终于找到了重点:

    //生成字节码
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);

    那么接下来我们也使用测试一下,使用这个方法生成的字节码是个什么样子:

    package jiankunking;
    
    import sun.misc.ProxyGenerator;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    /**
     * 动态代理演示
     */
    public class DynamicProxyDemonstration
    {
        public static void main(String[] args)
        {
            //代理的真实对象
            Subject realSubject = new RealSubject();
    
            /**
             * InvocationHandlerImpl 实现了 InvocationHandler 接口,并能实现方法调用从代理类到委托类的分派转发
             * 其内部通常包含指向委托类实例的引用,用于真正执行分派转发过来的方法调用.
             * 即:要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法
             */
            InvocationHandler handler = new InvocationHandlerImpl(realSubject);
    
            ClassLoader loader = handler.getClass().getClassLoader();
            Class[] interfaces = realSubject.getClass().getInterfaces();
            /**
             * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
             */
            Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);
    
            System.out.println("动态代理对象的类型:"+subject.getClass().getName());
    
            String hello = subject.SayHello("jiankunking");
            System.out.println(hello);
            // 将生成的字节码保存到本地,
            createProxyClassFile();
        }
        private static void createProxyClassFile(){
            String name = "ProxySubject";
            byte[] data = ProxyGenerator.generateProxyClass(name,new Class[]{Subject.class});
            FileOutputStream out =null;
            try {
                out = new FileOutputStream(name+".class");
                System.out.println((new File("hello")).getAbsolutePath());
                out.write(data);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(null!=out) try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

    可以看一下这里代理对象的类型:

    我们用jd-jui 工具将生成的字节码反编译:

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    import jiankunking.Subject;
    
    public final class ProxySubject
      extends Proxy
      implements Subject
    {
      private static Method m1;
      private static Method m3;
      private static Method m4;
      private static Method m2;
      private static Method m0;
      
      public ProxySubject(InvocationHandler paramInvocationHandler)
      {
        super(paramInvocationHandler);
      }
      
      public final boolean equals(Object paramObject)
      {
        try
        {
          return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final String SayGoodBye()
      {
        try
        {
          return (String)this.h.invoke(this, m3, null);
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final String SayHello(String paramString)
      {
        try
        {
          return (String)this.h.invoke(this, m4, new Object[] { paramString });
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final String toString()
      {
        try
        {
          return (String)this.h.invoke(this, m2, null);
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final int hashCode()
      {
        try
        {
          return ((Integer)this.h.invoke(this, m0, null)).intValue();
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      static
      {
        try
        {
          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
          m3 = Class.forName("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]);
          m4 = Class.forName("jiankunking.Subject").getMethod("SayHello", new Class[] { Class.forName("java.lang.String") });
          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
          return;
        }
        catch (NoSuchMethodException localNoSuchMethodException)
        {
          throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException localClassNotFoundException)
        {
          throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
      }
    }

    这就是最终真正的代理类,它继承自Proxy并实现了我们定义的Subject接口,也就是说:

    Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);

    这里的subject实际是这个类的一个实例,那么我们调用它的:

    public final String SayHello(String paramString)

    就是调用我们定义的InvocationHandlerImpl的 invoke方法:

    ======================横线之间的是代码跟分析的过程,不想看的朋友可以直接看结论=====================================

    五、结论

    到了这里,终于解答了:
    subject.SayHello("jiankunking")这句话时,为什么会自动调用InvocationHandlerImpl的invoke方法?
    因为JDK生成的最终真正的代理类,它继承自Proxy并实现了我们定义的Subject接口,
    在实现Subject接口方法的内部,通过反射调用了InvocationHandlerImpl的invoke方法。
    包含生成本地class文件的demo:
    javajdk动态代理演示demo2-Java代码类资源-CSDN下载
    GitHub - jiankunking/DynamicProxyDemo: java jdk 动态代理
    通过分析代码可以看出Java 动态代理,具体有如下四步骤:

    1. 通过实现 InvocationHandler 接口创建自己的调用处理器;
    2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类;
    3. 通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型;
    4. 通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入。

    个人微信公众号:

    作者:jiankunking 出处:衣舞晨风的博客_CSDN博客-C#,Java,Sql Server领域博主

    本文参考过:

    Java动态代理的使用及原理分析 - JAVA编程语言程序开发技术文章 - 红黑联盟

    IBM Developer

    展开全文
  • Java动态代理

    千次阅读 2021-09-24 10:43:00
     动态代理技术是整个java技术中最重要的一个技术,它是学习java框架的基础,不会动态代理技术,那么在学习Spring这些框架时是学不明白的。 动态代理技术就是用来产生一个对象的代理对象的。在开发中为什么需要为一...

    一、代理的概念

    动态代理技术是整个java技术中最重要的一个技术,它是学习java框架的基础,不会动态代理技术,那么在学习Spring这些框架时是学不明白的。

    动态代理技术就是用来产生一个对象的代理对象的。在开发中为什么需要为一个对象产生代理对象呢?
      举一个现实生活中的例子:歌星或者明星都有一个自己的经纪人,这个经纪人就是他们的代理人,当我们需要找明星表演时,不能直接找到该明星,只能是找明星的代理人。比如刘德华在现实生活中非常有名,会唱歌,会跳舞,会拍戏,刘德华在没有出名之前,我们可以直接找他唱歌,跳舞,拍戏,刘德华出名之后,他干的第一件事就是找一个经纪人,这个经纪人就是刘德华的代理人(代理),当我们需要找刘德华表演时,不能直接找到刘德华了(刘德华说,你找我代理人商谈具体事宜吧!),只能是找刘德华的代理人,因此刘德华这个代理人存在的价值就是拦截我们对刘德华的直接访问!
      这个现实中的例子和我们在开发中是一样的,我们在开发中之所以要产生一个对象的代理对象,主要用于拦截对真实业务对象的访问。那么代理对象应该具有什么方法呢?代理对象应该具有和目标对象相同的方法。

    所以在这里明确代理对象的两个概念:
        1、代理对象存在的价值主要用于拦截对真实业务对象的访问。
        2、代理对象应该具有和目标对象(真实业务对象)相同的方法。

    刘德华(真实业务对象)会唱歌,会跳舞,会拍戏,我们现在不能直接找他唱歌,跳舞,拍戏了,只能找他的代理人(代理对象)唱歌,跳舞,拍戏,一个人要想成为刘德华的代理人,那么他必须具有和刘德华一样的行为(会唱歌,会跳舞,会拍戏),刘德华有什么方法,他(代理人)就要有什么方法,我们找刘德华的代理人唱歌,跳舞,拍戏,但是代理人不是真的懂得唱歌,跳舞,拍戏的,真正懂得唱歌,跳舞,拍戏的是刘德华,在现实中的例子就是我们要找刘德华唱歌,跳舞,拍戏,那么只能先找他的经纪人,交钱给他的经纪人,然后经纪人再让刘德华去唱歌,跳舞,拍戏。

    二、java中的代理

    使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用,分派到目标对象上反射执行,还可以在分派过程中添加"前置通知"和后置处理(是在invoke方法中添加,如在调用目标方法前校验权限,在调用完目标方法后打印日志等)等功能。

    在这里插入图片描述
    使用动态代理的五大步骤

    1.通过实现InvocationHandler接口来自定义自己的InvocationHandler(主要是编写invoke方法);
    2.通过Proxy.getProxyClass获得动态代理类
    3.通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class)
    4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入

    5.通过代理对象调用目标方法

    2.1、"java.lang.reflect.Proxy"类介绍
      现在要生成某一个对象的代理对象,这个代理对象通常也要编写一个类来生成,所以首先要编写用于生成代理对象的类。在java中如何用程序去生成一个对象的代理对象呢,java在JDK1.5之后提供了一个"java.lang.reflect.Proxy"类,通过"Proxy"类提供的一个newProxyInstance方法用来创建一个对象的代理对象,如下所示:

     static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
    

    newProxyInstance方法用来返回一个代理对象,这个方法总共有3个参数:

    ClassLoader loader:用来指明生成代理对象使用哪个类装载器 Class<?>[]
    interfaces:用来指明生成哪个对象的代理对象(代理类和目标类实现相同的接口) InvocationHandler h :
    用来指明产生的这个代理对象要做什么事情。(这个InvocationHandler 就是我们自己定义的InvocationHandler
    对象,里边有我们编写invok方法)

    newProxyInstance方法生成代理对象过程:

    a. 通过Proxy.getProxyClass(ProxyGenerator.generateProxyClass(proxyName, interfaces);)获得动态代理类的class字节码内容。
    b.把字节码通过传入的类加载器加载到虚拟机中,然后通过反射机制获得代理类的构造方法(方法签名为getConstructor(InvocationHandler.class)),生成代理类对象

      public final void dance(String paramString)
      {
        try
        {
          h.invoke(this, m4, new Object[] { paramString });
          return;
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
     
      public final void sing(String paramString)
      {
        try
        {
          h.invoke(this, m3, new Object[] { paramString });
          return;
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
     
    ///
     
    static{
        m3 = Class.forName("com.sun.proxy.$Proxy0").getMethod("sing", new Class[] { Class.forName("java.lang.String") });
        m4 = Class.forName("com.sun.proxy.$Proxy0").getMethod("dance", new Class[] { Class.forName("java.lang.String") });
          
        m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
        m6 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getInvocationHandler", new Class[] { Class.forName("java.lang.Object") });
        m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
        m7 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getProxyClass", new Class[] { Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;") });
        
        m12 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getClass", new Class[0]);
        m14 = Class.forName("com.sun.proxy.$Proxy0").getMethod("notifyAll", new Class[0]);
        m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        m9 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", new Class[0]);
        m13 = Class.forName("com.sun.proxy.$Proxy0").getMethod("notify", new Class[0]);
        m8 = Class.forName("com.sun.proxy.$Proxy0").getMethod("newProxyInstance", new Class[] { Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"), Class.forName("java.lang.reflect.InvocationHandler") });
        m11 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", new Class[] { Long.TYPE });
        m5 = Class.forName("com.sun.proxy.$Proxy0").getMethod("isProxyClass", new Class[] { Class.forName("java.lang.Class") });
        m10 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", new Class[] { Long.TYPE, Integer.TYPE });
    }
    

    dance(String paramString) 与之相呼应:代理类和目标类实现相同的接口

    h.invoke(this, m4, new Object[] { paramString }); //m4:代理类的方法,和目标类的方法,一一对应。
    m4 = Class.forName(“com.sun.proxy.$Proxy0”).getMethod(“dance”, newClass[] { Class.forName(“java.lang.String”) }); 与之相呼应: 这里调用的是我们自定义的InvocationHandler 对象h的invoke方法,所以就实现了可以拦截、添加前置后置处理。

    这也说明了代理逻辑 和 动态代理本身是代码分离的,程序员只需要关注好自己的代理逻辑就行,动态代理本身就交给jdk本身去处理。在jdk动态代理中,美中不足就是整个设计都是针对接口做的代理,如果是普通的类,我们无法通过这个方式代理对象(通过生成的代理类也知道没有接口是不行的),但是我们知道 通过拼接字节码生成新的类自由度是十分大的,这也就启示我们 设计不管是针对接口类还是普通类的代理类 是完全可行的,比如cglib框架就是通过拼接字节码来实现非接口类的代理。 后面会介绍如何 实现这种操作,我在自己的Simplify-Core项目中已经尝试通过asm框架(字节码读写框架)实现代理操作。

    展开全文
  • Java 动态代理类

    万次阅读 多人点赞 2018-07-24 23:42:58
    为了保持行为的一致性,代理类和委托通常会实现相同的接口,所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层,能有效控制对委托对象的直接访问,也可以很好地隐藏和保护委托...

    一、什么是代理?

    代理是一种常用的设计模式,其目的就是为真实对象提供一个代理对象以控制对真实对象的访问。代理类负责为委托类(被代理类、真实类)预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理。
    这里写图片描述

    为了保持行为的一致性,代理类和委托类通常会实现相同的接口,所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层,能有效控制对委托类对象的直接访问,也可以很好地隐藏和保护委托类对象,同时也为实施不同控制策略预留了空间,从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

    二、Java 动态代理类

    Java动态代理类位于java.lang.reflect包下,一般主要涉及到以下两个类:

    (1)Interface InvocationHandler:该接口中仅定义了一个方法

    public Object invoke(Object obj,Method method, Object[] args)

    public object invoke(Object obj,Method method, Object[] args)
    在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,如上例中的request(),args为该方法的参数数组。这个抽象方法在代理类中动态实现。

    (2)Proxy:该类即为动态代理类,其中主要包含以下内容:

    protected Proxy(InvocationHandler h):构造函数,用于给内部的h赋值。

    static Class getProxyClass (ClassLoaderloader, Class[] interfaces):获得一个代理类,其中loader是类装载器,interfaces是真实类所拥有的全部接口的数组。

    static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h):返回代理类的一个实例,返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)

    所谓DynamicProxy是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然,这个DynamicProxy其实就是一个Proxy,它不会替你作实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作。

    在使用动态代理类时,我们必须实现InvocationHandler接口

    通过这种方式,被代理的对象(RealSubject)可以在运行时动态改变,需要控制的接口(Subject接口)可以在运行时改变,控制的方式(DynamicSubject类)也可以动态改变,从而实现了非常灵活的动态代理关系。

    动态代理步骤:

    1. 创建被代理的类(委托类、真实类)(RealSubject)及其接口(RealSubjectInterface)
    2. 创建一个实现接口InvocationHandler的类(InvocationHandlerImpl),它必须实现接口的invoke方法
    3. 通过Proxy的静态方法newProxyInstance(), 创建一个代理对象(realSubjectProxy),
      RealSubjectInterface realSubjectProxy= (RealSubjectInterface) Proxy.newProxyInstance(loader,interfaces,handler);
    4. 通过代理对象(realSubjectProxy)调用 委托类对象( realSubject)的方法

    三、JDK的动态代理 实现步骤?

    1.创建被代理的类的接口RealSubjectInterface

    package cn.alibaba.dynamic_proxy;
    
    /**
     * 真实对象的实现接口:需要动态代理的接口
     */
    public interface RealSubjectInterface {
        /**
         *定义方法
         */
        public String SayHello(String name);
    
        public String SayGoodBye();
    
    }
    

    2、创建被代理的类(委托类、真实类)RealSubject

    package cn.alibaba.dynamic_proxy;
    
    public class RealSubject implements RealSubjectInterface{
        @Override
        public String SayHello(String name) {
    
            return "hello, " + name;
        }
    
        @Override
        public String SayGoodBye() {
    
            return " good bye ";
        }
    }
    

    3、创建一个实现接口InvocationHandler的类InvocationHandlerImpl
    即调用处理器实现类(传说中的AOP?)

    package cn.alibaba.dynamic_proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    /**
     *调用处理器实现类(有木有感觉这里就是传说中的AOP啊)
     * 每次生成动态代理类对象的时候都需要指定一个实现了该接口的调用处理器类
     *  */
    
    public class InvocationHandlerImpl implements InvocationHandler{
        /**
         * 我们要代理的真实对象
         */
        private Object realSubject;//为了new InvocationHandlerImpl(realSubject);传参名一致
    
        /**
         * 构造函数,为真实对象赋初值
         */
        public InvocationHandlerImpl(Object realSubject){
            this.realSubject =realSubject;
        }
        /**
         * invoke方法负责处理动态代理类中所有方法调用
         * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
         * @param proxy
         * @param method
         * @param args
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //在代理真实对象前可以添加额外操作
            System.out.println("在用代理对象调用真实对象的方法之前,类似AOP的Before(),自己的操作:");
            System.out.println("其调用的方法Method:"+method);
    
            //当代理对象调用真实对象的方法时,其会自动跳转到代理对象关联的handler对象的invoke方法来进行调用
            Object returnValue=method.invoke(realSubject,args);
    
            //在代理真实对象之后可以添加额外操作
            System.out.println("在用代理对象调用真实对象的方法之后,但是返回值returnValue之前,自己的操作?");
    
            return returnValue;
            }
    }
    

    4、动态代理测试

    package cn.alibaba.dynamic_proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    /**
     * 动态代理测试
     */
    public class DynamicProxyDemonstration {
        public static void main(String[] args) {
            //创建要被代理的真实对象
            RealSubjectInterface realSubject=new RealSubject();
    
            /**
             * InvocationHandlerImpl 实现了 InvocationHandler 接口,并能实现方法调用从代理类到委托类的分派转发
             * 其内部通常包含指向委托类实例的引用,用于真正执行分派转发过来的方法调用.
             * 即:要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法
             */
            InvocationHandler handler =new InvocationHandlerImpl(realSubject);
    
            ClassLoader loader=realSubject.getClass().getClassLoader();
            Class []interfaces=realSubject.getClass().getInterfaces();
    
            /**
             * Proxy.newProxyInstance该方法用于为指定类加载器,一组接口,调用处理器生成动态代理类对象
             */
            RealSubjectInterface realSubjectProxy= (RealSubjectInterface) Proxy.newProxyInstance(loader,interfaces,handler);
    
            System.out.println("动态代理对象的类型:"+realSubjectProxy.getClass().getName());
    
            //用动态代理类对象 调用 真实对象的方法
            System.out.println(realSubjectProxy.SayHello("Jason zhang"));
    
            //System.out.println("/*************************************/");
    
           // System.out.println(realSubjectProxy.SayGoodBye());
    
        }
    
    }
    

    5、测试结果
    这里写图片描述

    四、源码分析过程

    参考:https://blog.csdn.net/jiankunking/article/details/52143504

    分析newProxyInstance()源码发现:最终真正的代理类,它继承自Proxy并实现了我们定义的RealSubjectInterface 接口

    RealSubjectInterface realSubjectProxy= (RealSubjectInterface) Proxy.newProxyInstance(loader,interfaces,handler);

    这里的realSubjectProxy实际是这个类的一个实例,那么我们调用它的:

    public String SayHello(String name);

    就是调用我们定义的InvocationHandlerImpl的 invoke方法:
    这里写图片描述

    五、结论

    realSubjectProxy.SayHello(“Jason zhang”)这句话时,为什么会自动调用InvocationHandlerImpl的invoke方法?

    因为JDK生成的最终真正的代理类,它继承自Proxy并实现了我们定义的RealSubjectInterface 接口,在实现RealSubjectInterface 接口方法的内部,通过反射调用了InvocationHandlerImpl 的invoke方法

    代理类和委托类通常会实现相同的接口,所以在访问者看来两者没有丝毫的区别。

    通过分析代码可以看出Java 动态代理,具体有如下四步骤:

    1. 通过实现 InvocationHandler 接口创建自己的调用处理器类;
    2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类;
    3. 通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型;
    4. 通过构造函数创建动态代理类实例,构造时调用处理器对象(handler)作为参数被传入。
    展开全文
  • java动态代理实现接口调用

    千次阅读 2019-10-14 11:17:33
    动态代理是基于接口实现的代理,...首先,创建一个最基本接口和实现类: interface UserManager { void addUser(); } class UserManagerImpl implements UserManager{ @Override public void addUser() { Sy...
  • 上篇介绍了一下静态代理Java中的代理模式——静态代理以及分析静态代理的缺点 也分析了一下静态代理的缺点: 1、由于静态代理中的代理类是针对某一个去做代理的,那么假设一个系统中有100个Service,则需要...
  • 四、动态代理的JDK实现原理 4.1核心/接口 4.2 代理类$Proxy0解析 4.3 动态代理的经典使用五、手写代码模拟JDK动态代理六、参考资料项目源码已经上传,欢迎点击下载~先将自己总结的Java动态代理UML图放在前面,...
  • Java两种动态代理JDK动态代理和CGLIB动态代理

    万次阅读 多人点赞 2018-08-07 15:33:35
    目录 代理模式 JDK动态代理 ...但是B是“真正”实现类,A则比较“虚”,他借用了B的方法去实现接口的方法。A虽然是“伪军”,但它可以增强B,在调用B的方法前后都做些其他的事情。Spring AOP...
  • java动态代理

    万次阅读 多人点赞 2018-12-28 13:46:28
    关于动态代理首先需要了解代理模式,根据代理类的创建时间又可以分为静态代理动态代理。 1、代理模式 代理模式是常见的设计模式之一,Java我们通常通过new一个对象然后调用其对应的方法来访问我们需要的服务。...
  • Java动态代理实现原理

    万次阅读 多人点赞 2018-09-25 11:20:57
    静态代理 动态代理 基于JDK的动态代理 基于继承的动态代理
  • java代理类详解

    千次阅读 多人点赞 2021-11-20 20:52:26
    ???? Java学习路线配套文章:Java学习路线总结,搬砖工逆袭Java架构师(全网最强) ???... 基础推荐:Java基础教程系列 ...目录一、代理模式二、组成三、优点1、职责清晰2、保护对象3、高扩展性四、模式结构五、静态
  • java动态代理实现

    千次阅读 多人点赞 2019-01-15 14:42:46
    关于Java中的动态代理,我们首先需要了解的是一种常用的设计模式--代理模式,而对于代理,根据创建代理类的时间点,又可以分为静态代理动态代理。  一、代理模式  代理模式是常用的java设计模式,他的特征是...
  • Java实现动态代理示例

    千次阅读 2018-08-15 10:38:16
    首先定义一个接口 public interface IStars { void sing(); void dance();...然后定义一个star实现这个接口 public class Stars implements IStars { private String name; publ...
  • 什么是Java动态代理,如何实现一个动态代理例子

    千次阅读 多人点赞 2019-09-04 11:06:15
    Java动态代理 一、概述 1. 什么是代理 我们大家都知道微商代理,简单地说就是代替厂家卖商品,厂家“委托”代理为其销售商品。关于微商代理,首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁,也就是说...
  • Java JDK 动态代理实现和代码分析

    千次阅读 2021-06-02 20:51:44
    JDK 动态代理 API5.1 java.lang.reflect.Proxy5.1 java.lang.reflect.InvocationHandler二、JDK 动态代理实现(代码)1. 项目结构图2. IRentService 接口3. LandlordServiceImpl 真实4. ...
  • 为什么需要动态代理??比如苹果公司 为了 在 中国 卖手机, 联系找了 一个生产手机的厂家, 还有一个 做销售的公司。苹果 公司提供一个接口,告诉生产厂家,给我制造6s、6p、7 还有x 这 4种手机然后生产厂家 就去按...
  • 轻松学,Java 中的代理模式及动态代理

    万次阅读 多人点赞 2017-06-29 22:08:55
    前几天我写了《秒懂,Java 注解 (Annotation)你可以这样学》,因为注解其实算反射技术中的一部分,然后我想了一下,反射技术中还有个常见的概念就是动态代理,于是索性再写一篇关于动态代理的博文好了。...
  • Javaweb安全学习——Java动态代理

    千次阅读 2022-04-05 02:10:38
    Javajava.lang.reflect包下提供了一个Proxy类和InvocationHandler接口,可以生成JDK动态代理类或对象来完成程序侵入式扩展(即不通过继承接口编写实现类来完成功能拓展)。 Java动态代理主要使用场景: 统计...
  • java中的静态、动态代理模式以及Spring中的CgLib动态代里解读(面试必问)     基础知: 反射知识 什么是反射 反射是框架的灵魂 JAVA反射机制是在运行状态中,对于任意一个,都能够知道这个的所有属性和方法...
  • JDK动态代理只支持代理接口,因为JDK动态代理生成的代理类默认实现了一个Proxy,鉴于Java单继承多实现机制,顾只支持代理接口。 CGLIB动态代理既支持代理接口也支持代理类动态生成的代理类根据代理的对象情况,...
  • 前言 如果你学习过spring,那么你一定接触和使用过Aop。...java原生的动态代理代理的对象必须要实现一个顶级接口,而cglib的动态代理则不需要这样的接口。在很长一段时间里很迷惑为什么java动态代...
  • 动态代理是 AOP(Aspect Orient Programming)编程思想,理解...CGLIB通过继承的方式进行代理,无论目标对象有没有实现接口都可以代理,但是无法代理final对象与final方法。(final类型不能有子类,final方法不能被重载)
  • 1.为什么会有这样的想法去生成接口的实现类 在学习mybatis的过程中...思考:由于我们没有写该接口的实现类,mybatis返回的对象肯定不是简单的动态代理 但是我们打印其返回对象的class发现 class com.sun.proxy.$...
  • 之前本人在设计模式中有写过静态代理动态代理的相关代码测试,可以看下。 今天我们主要学一下理论...代理类实现InvocationHandler,帮助被代理类实现方法。 代理:https://www.cnblogs.com/xiaoluo501395377/p/...
  • **代理模式:接口+真实实现类+代理类, 真实类和 代理类 需要实现同一个接口 代理类中的构造方法使用 接口作为构造方法 的参数 : 这样创建对象时候实例化 可以将真实类的对象作为参数传递给代理类 由代理类处理 ...
  • [Java|面试] 面试被问Java动态代理机制,能说说吗

    千次阅读 多人点赞 2021-05-26 15:06:17
    Java动态代理机制 文章目录Java动态代理机制0. 什么是代理1.动态代理和静态代理的区别2. 使用代理的情况3. 动态代理的构成4. JDK中的动态代理5. 手写一个JDK动态规划的demo6. 总结 0. 什么是代理 代理是基本的...
  • JAVA动态代理实现RPC框架

    千次阅读 2016-08-17 17:15:25
    动态代理其实就是Java.lang.reflect.Proxy类动态的根据指定的所有接口生成一个class byte,该class会继承Proxy,并实现所有指定的接口(在参数中传入的接口数组),也就 是说,返回的对象可以转换类型为接口数组中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 365,094
精华内容 146,037
关键字:

java无实现类动态代理

java 订阅