自行建网站 所需费用,郑州软件开发外包,项目符号在哪里设置,新能源汽车价格补贴分享来源#xff1a;微信号#xff1a;java一日一条 要想了解Java动态代理#xff0c;首先要了解什么叫做代理#xff0c;熟悉设计模式的朋友一定知道在Gof总结的23种设计模式中#xff0c;有一种叫做代理(Proxy)的对象结构型模式#xff0c;动态代理中的代理#xff0c…分享来源微信号java一日一条         要想了解Java动态代理首先要了解什么叫做代理熟悉设计模式的朋友一定知道在Gof总结的23种设计模式中有一种叫做代理(Proxy)的对象结构型模式动态代理中的代理指的就是这种设计模式。 在我看来所谓的代理模式和23种设计模式中的“装饰模式”是一个东西。23种设计模式中将它们作为两种模式网上也有些文章讲这两种模式的异同从细节来看确实可以人为地区分这两种模式但是抽象到一定高度后我认为这两种模式是完全一样的。因此学会了代理模式也就同时掌握了装饰模式。 代理模式 代理模式简单来说就是对一个对象进行包装包装后生成的对象具有和原对象一样的方法列表但是每个方法都可以是被包装过的。 静态代理 让我们先来看一段代码 package common;   public class Test {    static interface Subject{        void sayHi();        void sayHello();     }      static class SubjectImpl implements Subject{          Override         public void sayHi() {            System.out.println(hi);        }          Override        public void sayHello() {            System.out.println(hello);        }     }      static class SubjectImplProxy implements Subject{        private Subject target;          public SubjectImplProxy(Subject target) {            this.targettarget;        }          Override        public void sayHi() {            System.out.print(say:);            target.sayHi();        }          Override        public void sayHello() {            System.out.print(say:);            target.sayHello();        }     }      public static void main(String[] args) {        Subject subjectnew SubjectImpl();        Subject subjectProxynew SubjectImplProxy(subject);        subjectProxy.sayHi();        subjectProxy.sayHello();     } } 这段代码中首先定义了一个Subject接口接口中有两个方法。 然后定义了SubjectImpl类实现Subject接口并实现其中的两个方法到这里肯定是没问题的。 现在再定义一个SubjuectImplProxy类也实现Subject接口。这个SubjectImplProxy类的作用是包装SubjectImpl类的实例它的内部定义一个变量target来保存一个SubjectImpl的实例。SubjectImplProxy也实现了接口规定的两个方法并且在它的实现版本中都调用了SubjectImpl的实现但是又添加了自己的处理逻辑。 相信这段代码不难理解它通过对SubjectImpl进行包装达到了给输出内容添加前缀的功能。这种代理方式叫做静态代理。 动态代理 从上面的演示中我们不难看出静态代理的缺点我们对SubjectImpl的两个方法是进行的相同的包装但是却要在SubjectImplProxy里把相同的包装逻辑写两次而且以后如果Subject接口再添加新的方法SubjectImplProxy也必须要添加新的实现尽管SubjectImplProxy对所有方法的包装可能都是一样的。 下面我把上面例子的静态代理改成动态代理我们来看一下区别 package common;   import java.lang.invoke.MethodHandle; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;   public class Test {    static interface Subject{        void sayHi();        void sayHello();     }      static class SubjectImpl implements Subject{          Override        public void sayHi() {            System.out.println(hi);        }          Override        public void sayHello() {            System.out.println(hello);        }     }      static class ProxyInvocationHandler implements InvocationHandler{        private Subject target;        public ProxyInvocationHandler(Subject target) {            this.targettarget;        }          Override        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {            System.out.print(say:);            return method.invoke(target, args);        }       }      public static void main(String[] args) {        Subject subjectnew SubjectImpl();        Subject subjectProxy(Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), new ProxyInvocationHandler(subject));        subjectProxy.sayHi();        subjectProxy.sayHello();       } } 只看main方法的话只有第二行和之前的静态代理不同同样是生成一个subjectProxy代理对象只是生成的代码不同了。静态代理是直接new 一个SubjectImplProxy的实例而动态代理则调用了java.lang.reflect.Proxy.newProxyInstance()方法我们来看一下这个方法的源码    public static Object newProxyInstance(ClassLoader loader,                                          Class?[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException     {        if (h null) {            throw new NullPointerException();        }          /*         * Look up or generate the designated proxy class.         */        Class? cl getProxyClass(loader, interfaces);　　//获取代理类的Class          /*         * Invoke its constructor with the designated invocation handler.         */        try {             Constructor cons cl.getConstructor(constructorParams);　　//constructorParams是写死的 { InvocationHandler.class }上边返回的代理类Class一定是extends Proxy的而Proxy有一个参数为InvocationHandler的构造函数              return cons.newInstance(new Object[] { h });　　//这里通过构造函数将我们自己定义的InvocationHandler的子类传到代理类的实例里当我们调用代理类的任何方法时实际上都会调用我们定义的InvocationHandler子类重写的invoke()函数        } catch (NoSuchMethodException e) {            throw new InternalError(e.toString());        } catch (IllegalAccessException e) {            throw new InternalError(e.toString());        } catch (InstantiationException e) {            throw new InternalError(e.toString());        } catch (InvocationTargetException e) {            throw new InternalError(e.toString());        }     } 上面的 Class? cl getProxyClass(loader, interfaces);  调用的getProxyClass方法 public static Class? getProxyClass(ClassLoader loader,                                         Class?... interfaces)        throws IllegalArgumentException     {        if (interfaces.length 65535) {　　//因为在class文件中一个类保存的接口数量是用2个字节来表示的因此java中一个类最多可以实现65535个接口            throw new IllegalArgumentException(interface limit exceeded);        }          Class? proxyClass null;          /* collect interface names to use as key for proxy class cache */        String[] interfaceNames new String[interfaces.length];          // for detecting duplicates        SetClass? interfaceSet new HashSet();   　　　　 //验证interfaces里的接口是否能被类加载器加载是否是接口是否有重复的　          for (int i 0; i interfaces.length; i) {            /*             * Verify that the class loader resolves the name of this             * interface to the same Class object.             */            String interfaceName interfaces[i].getName();            Class? interfaceClass null;            try {                 interfaceClass Class.forName(interfaceName, false, loader);            } catch (ClassNotFoundException e) {            }            if (interfaceClass ! interfaces[i]) {                 throw new IllegalArgumentException(                     interfaces[i] 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.contains(interfaceClass)) {                 throw new IllegalArgumentException(                     repeated interface: interfaceClass.getName());            }            interfaceSet.add(interfaceClass);              interfaceNames[i] interfaceName;        }          /*         * Using string representations of the proxy interfaces as         * keys in the proxy class cache (instead of their Class         * objects) is sufficient because we require the proxy         * interfaces to be resolvable by name through the supplied         * class loader, and it has the advantage that using a string         * representation of a class makes for an implicit weak         * reference to the class.         */        ListString key Arrays.asList(interfaceNames);　　        //使用interfaces列表作为key缓存在cache里也就是实现了相同interfaces的代理类只会创建加载一次          /*         * Find or create the proxy class cache for the class loader.         */        MapListString, Object cache;        synchronized (loaderToCache) {            cache loaderToCache.get(loader);            if (cache null) {                 cache new HashMap();                 loaderToCache.put(loader, cache);             }            /*             * This mapping will remain valid for the duration of this             * method, without further synchronization, because the mapping             * will only be removed if the class loader becomes unreachable.             */        }          /*         * Look up the list of interfaces in the proxy class cache using         * the key.  This lookup will result in one of three possible         * kinds of values:         *     null, if there is currently no proxy class for the list of         *         interfaces in the class loader,         *     the pendingGenerationMarker object, if a proxy class for the         *         list of interfaces is currently being generated,         *     or a weak reference to a Class object, if a proxy class for         *         the list of interfaces has already been generated.         */ 　　　　 //看看缓存里有没有如果有就直接取出来然后return否则判断根据pendingGenerationMarker判断是否有其它线程正在生成当前的代理类如果有则cache.wait()等待如果没有则创建。        synchronized (cache) {            /*             * Note that we need not worry about reaping the cache for             * entries with cleared weak references because if a proxy class             * has been garbage collected, its class loader will have been             * garbage collected as well, so the entire cache will be reaped             * from the loaderToCache map.             */            do {                 Object value cache.get(key);                 if (value instanceof Reference) {                     proxyClass (Class?) ((Reference) value).get();                 }                 if (proxyClass ! null) {                     // proxy class already generated: return it                     return proxyClass;                 } else if (value pendingGenerationMarker) {                     // proxy class being generated: wait for it                     try {                         cache.wait();                     } catch (InterruptedException e) {                         /*                          * The class generation that we are waiting for should                          * take a small, bounded time, so we can safely ignore                          * thread interrupts here.                          */                     }                     continue;                 } else {                     /*                      * No proxy class for this list of interfaces has been                      * generated or is being generated, so we will go and                      * generate it now.  Mark it as pending generation.                      */                     cache.put(key, pendingGenerationMarker);                     break;                 }            } while (true);        } 　　　　 //确认要生成的代理类所属的包如果interfaces里所有接口都是public的代理类所属包就是默认包如果有interface不是public那么所有不是public的interface必须在一个包里否则报错。        try {            String proxyPkg null;     // package to define proxy class in              /*             * 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 (int i 0; i interfaces.length; i) {                 int flags interfaces[i].getModifiers();                 if (!Modifier.isPublic(flags)) {                     String name interfaces[i].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,                 proxyPkg ;          // use the unnamed package            }              {                 /*                  * Choose a name for the proxy class to generate.                  */                 long num;                 synchronized (nextUniqueNumberLock) {                     num nextUniqueNumber;                 }                 String proxyName proxyPkg proxyClassNamePrefix num;　　//生成代理类的名字proxyPkg是上面确定下来的代理类所在的包名proxyClassNamePrefix是写死的字符串“$Proxy”num是一个全局唯一的long型数字从0开始累积每次生成新的代理类就1从这里也能看出生成的动态代理类的数量不能超过Long.maxValue                 /*                  * Verify that the class loader hasnt already                  * defined a class with the chosen name.                  */                   /*                  * Generate the specified proxy class.                 */                 byte[] proxyClassFile ProxyGenerator.generateProxyClass(                     proxyName, interfaces);　　//生成一个以proxyName为类名的实现了Interfaces里所有接口的类的字节码                 try {                     proxyClass 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());                 }            }            // add to set of all generated proxy classes, for isProxyClass            proxyClasses.put(proxyClass, null);          } finally {            /*             * We must clean up the pending generation state of the proxy             * class cache entry somehow.  If a proxy class was successfully             * generated, store it in the cache (with a weak reference);             * otherwise, remove the reserved entry. In all cases, notify             * all waiters on reserved entries in this cache.             */ 　　　　　　　//创建成功则将cache中该key的pendingGenerationMarker替换为实际的代理类的弱引用否则也要清除pendingGenerationMarker标记不管是否成功都要执行cache.notifyAll()让其它要创建相同代理类并且执行了cache.wait()的线程恢复执行。            synchronized (cache) {                 if (proxyClass ! null) {                     cache.put(key, new WeakReferenceClass?(proxyClass));                 } else {                     cache.remove(key);                 }                 cache.notifyAll();            }        }        return proxyClass; //最后返回代理类Class     }   到这里我们已经把动态代理的java源代码都解析完了现在思路就很清晰了 Proxy.newProxyInstance(ClassLoader loader,Class?[] interfaces,InvocationHandler h) 方法简单来说执行了以下操作 1.生成一个实现了参数interfaces里所有接口且继承了Proxy的代理类的字节码然后用参数里的classLoader加载这个代理类。   2.使用代理类父类的构造函数 Proxy(InvocationHandler h)来创造一个代理类的实例将我们自定义的InvocationHandler的子类传入。   3.返回这个代理类实例因为我们构造的代理类实现了interfaces也就是我们程序中传入的subject.getClass().getInterfaces()里的所有接口因此返回的代理类可以强转成Subject类型来调用接口中定义的方法。   现在我们知道了用Proxy.newProxyInstance()返回的subjectProxy可以成功强转成Subject类型来调用接口中定义的方法了那么在调用方法后代理类实例怎么进行处理的呢这就需要看一下代理类的源码了。但是代理类是程序动态生成字节码加载的怎么看源码呢没关系可以在main方法中加入System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”,”true”)这样就会把生成的代理类Class文件保存在本地磁盘上然后再反编译可以得到代理类的源码 package common;   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 Test.Subject {  private static Method m4;  private static Method m1;  private static Method m3;  private static Method m0;  private static Method m2;    static   {      try {          m4 Class.forName(Test$Subject).getMethod(sayHello, new Class[0]);          m1 Class.forName(java.lang.Object).getMethod(equals, new Class[] { Class.forName(java.lang.Object) });          m3 Class.forName(Test$Subject).getMethod(sayHi, new Class[0]);          m0 Class.forName(java.lang.Object).getMethod(hashCode, new Class[0]);          m2 Class.forName(java.lang.Object).getMethod(toString, new Class[0]);     } catch (Exception e) {         throw new RuntimeException(e);     }   }    public $Proxy0(InvocationHandler paramInvocationHandler)   {    super(paramInvocationHandler);   }    public final void sayHello()   {    try     {      this.h.invoke(this, m4, null);      return;     }     catch (RuntimeException localRuntimeException)     {      throw localRuntimeException;     }    catch (Throwable localThrowable)     {        throw new UndeclaredThrowableException(localThrowable);     }   }    public final boolean equals(Object paramObject)   {    try     {      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();     }    catch (RuntimeException localRuntimeException)     {      throw localRuntimeException;     }    catch (Throwable localThrowable)     {        throw new UndeclaredThrowableException(localThrowable);     }   }    public final void sayHi()   {    try     {      this.h.invoke(this, m3, null);      return;     }    catch (RuntimeException localRuntimeException)     {      throw localRuntimeException;     }    catch (Throwable localThrowable)     {        throw new UndeclaredThrowableException(localThrowable);     }   }    public final int hashCode()   {    try     {      return ((Integer)this.h.invoke(this, m0, null)).intValue();     }    catch (RuntimeException localRuntimeException)     {      throw localRuntimeException;     }    catch (Throwable localThrowable)     {        throw new UndeclaredThrowableException(localThrowable);     }   }    public final String toString()   {    try     {      return (String)this.h.invoke(this, m2, null);     }    catch (RuntimeException localRuntimeException)     {      throw localRuntimeException;     }    catch (Throwable localThrowable)     {        throw new UndeclaredThrowableException(localThrowable);     }   } }   我们可以看到代理类内部实现比较简单在调用每个代理类每个方法的时候都用反射去调h的invoke方法(也就是我们自定义的InvocationHandler的子类中重写的invoke方法)用参数传递了代理类实例、接口方法、调用参数列表这样我们在重写的invoke方法中就可以实现对所有方法的统一包装了。 总结 动态代理相对于静态代理在使用上的优点主要是能够对一个对象的所有方法进行统一包装而且后期被代理的类添加方法的时候动态代理类不需要改动。   缺点是要求被代理的类必须实现了接口因为动态代理类在实现的时候继承了Proxy类java不支持多继承因此动态代理类只能根据接口来定义方法。 最后动态代理之所以叫做动态代理是因为java在实现动态代理的时候动态代理类是在运行时动态生成和加载的相对的静态代理类和其他普通类一下在类加载阶段就加载了。转载于:https://www.cnblogs.com/tiger-fu/p/7831811.html