Blog.csdn.net/u010061691/…

Java JDK dynamic proxies are dynamically generated bytecode and reflection mechanism of a union, said many people are used to reflect the reflection mechanism, as long as get the corresponding Class Class object to call methods, access to the member variable and so on, then the JDK dynamic proxy is in the process of the program is run by the dynamic inspection of our maintenance code, On normal business code before, so how I call my normal business code, since the business may have a lot of kinds, that is to say, may have different classes, but have to perform the same check code, if we want to take Money, or modify the ID card, must be verified by can, this is obviously the two classes, one is Money, one is the ID, So when we call normal business code, we don’t know whose code we are calling, so we use reflection, by reflection, dynamically identify the type, and then call the method, if we want to get Money, then we should pass in an instance of Money, through this instance getDeclaredMethod, Or getMethod, get the method of the instance, and then you can call the method dynamically, just by adding the code that we’ve verified before you use reflection, which is how reflection applies to dynamic proxies. This part of the code requires us to implement our own InvocationHandler interface and implement the Invoke method, which in this case is our reflection implementation. Of course, in order to call the method of the corresponding class, we implement the invocationHandler class, which needs to hold the instance of the class we want to delegate.

Dynamic generation of bytecodes is a technique in which the type of bytecodes to be generated cannot be determined at compile time, that is, there is no corresponding Java file, so class files cannot be generated. For static proxy, we explicitly implement a proxy class, so bytecodes can be generated at compile time. But a dynamic proxy can’t clear to realize a certain kind of proxy class, is for all the business of a common class, because can’t decided to generate the business class at compile-time proxy class so will not be able to generate the bytecode, but is at run time, see our incoming what class instance is input, generate the corresponding class proxy class, If there is no bytecode file, then the class will not be loaded, let alone executed. Therefore, dynamic proxy technology will dynamically splice the bytecode file into a class file, which is a dynamically generated bytecode file. This technique is implemented in a Java class

Proxy static method, newProxyInstance (), which takes three arguments. The first argument is the classLoader of the proxied class. The second argument is all the interfaces of the proxied class. The third argument is an instance of our implementation class above (InvocationHandler), so this method returns a proxy class that dynamically concatenates the bytecode of the proxy class in this method.

Dynamic proxies have two main applications: The first is that if more than the code will use the same code, such as security checks and permissions validation, in is on the business module is used, typically on our business code in the head or the tail, so if it’s not dynamic proxy, the same code will be dispersed in each part of your program, the first use of the code is, the second is the maintainability is not high, If you want to change the way you access authentication, so you need to change every place in the program, it will be difficult to maintain, altogether we will all check code, are extracted, maintenance, together with such code maintenance together, then it is quite convenient, this is the aspect oriented programming is AOP, We maintain the inspection code together in a class called facets. AOP concepts are widely used in Spring, such as life transactions, which are implemented using AOP to dynamically add transactions to database operations. The second major application is an application similar to interceptors. Interceptors are applications that add checking code in front of your business code and execute your business code if they pass. If not, your business code will not be executed. Here is not fully use dynamic proxy, mainly with dynamic proxies in the reflection of the implementation, in the actual applications typically use the interceptor stack, which is a series of interceptor, means more legitimacy examination, an interceptor validation through into the next interceptor, when all interceptor verification through, is the real business code. This idea is in fact the chain of responsibility pattern in the design pattern, will have a great application in SpringMVC, below I simple manual implementation of an interceptor (not interceptor stack), this is both an interceptor, but also a dynamic proxy application, I hope to help you, here is my code.



I’ve been using JDK dynamic proxies before, but I haven’t been able to figure it out. For example, who calls the Invoke method of InvocationHandler, and how the proxy object is generated, have not been fully understood until the last few weeks.

Without further ado, let’s take a look at how the JDK dynamic is used.

Java code

  1. package dynamic.proxy;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. / * *
  8. * Implement your own InvocationHandler
  9. * @author zyb
  10. * @since 2012-8-9
  11. *
  12. * /
  13. public class MyInvocationHandler implements InvocationHandler {
  15. // Target object
  16. private Object target;
  18. / * *
  19. * Construction method
  20. * @param target Target object
  21. * /
  22. public MyInvocationHandler(Object target) {
  23. super();
  24. this.target = target;
  25. }
  28. / * *
  29. * The method that executes the target object
  30. * /
  31. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  33. // Simply print the target object’s method before executing it
  34. System.out.println(“——————before——————“);
  36. // Execute the target object’s method
  37. Object result = method.invoke(target, args);
  39. // Simply print after the target object’s method is executed
  40. System.out.println(“——————-after——————“);
  42. return result;
  43. }
  45. / * *
  46. * Gets the proxy object of the target object
  47. * @return Proxy object
  48. * /
  49. public Object getProxy() {
  50. return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
  51. target.getClass().getInterfaces(), this);
  52. }
  53. }
  55. package dynamic.proxy;
  57. / * *
  58. * Target object implementation interface, using JDK to generate proxy objects must implement an interface
  59. * @author zyb
  60. * @since 2012-8-9
  61. *
  62. * /
  63. public interface UserService {
  65. / * *
  66. * Target method
  67. * /
  68. public abstract void add();
  70. }
  72. package dynamic.proxy;
  74. / * *
  75. * Target object
  76. * @author zyb
  77. * @since 2012-8-9
  78. *
  79. * /
  80. public class UserServiceImpl implements UserService {
  82. /* (non-Javadoc)
  83. * @see dynamic.proxy.UserService#add()
  84. * /
  85. public void add() {
  86. System.out.println(“——————–add—————“);
  87. }
  88. }
  90. package dynamic.proxy;
  92. import org.junit.Test;
  94. / * *
  95. * Dynamic proxy test classes
  96. * @author zyb
  97. * @since 2012-8-9
  98. *
  99. * /
  100. public class ProxyTest {
  102. @Test
  103. public void testProxy() throws Throwable {
  104. // Instantiate the target object
  105. UserService userService = new UserServiceImpl();
  107. // Instantiate InvocationHandler
  108. MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
  110. // Generate a proxy object based on the target object
  111. UserService proxy = (UserService) invocationHandler.getProxy();
  113. // Call the method of the proxy object
  114. proxy.add();
  116. }
  117. }

The result is as follows: ——————before—————— ——————–add————— — — — — — — — — — — — — — — — — — — — after — — — — — — — — — — — — — — — — — –, it is very simple to use, actually this is basically a simple implementation of AOP, the methods perform before and after the target object has been enhanced. Spring’s AOP implementation actually uses Proxy and InvocationHandler. It’s easy to use, but it would be nice to know what’s going on behind it. Let’s start by looking at how the JDK generates proxy objects. Since the Proxy object is generated using the static newProxyInstance of the Proxy class, let’s go to its source code and see what it does.

Java code

  1. / * *
  2. * loader: class loader
  3. * interfaces: Interfaces implemented by the target object
  4. * h: Implementation class of InvocationHandler
  5. * /
  6. public static Object newProxyInstance(ClassLoader loader,
  7. Class
    [] interfaces,
  8. InvocationHandler h)
  9. throws IllegalArgumentException
  10. {
  11. if (h == null) {
  12. throw new NullPointerException();
  13. }
  15. / *
  16. * Look up or generate the designated proxy class.
  17. * /
  18. Class cl = getProxyClass(loader, interfaces);
  20. / *
  21. * Invoke its constructor with the designated invocation handler.
  22. * /
  23. try {
  24. // Call the constructor of the proxy object (i.e. $Proxy0(InvocationHandler h))
  25. Constructor cons = cl.getConstructor(constructorParams);
  26. // Generate an instance of the proxy class and pass an instance of MyInvocationHandler to its constructor
  27. return (Object) cons.newInstance(new Object[] { h });
  28. } catch (NoSuchMethodException e) {
  29. throw new InternalError(e.toString());
  30. } catch (IllegalAccessException e) {
  31. throw new InternalError(e.toString());
  32. } catch (InstantiationException e) {
  33. throw new InternalError(e.toString());
  34. } catch (InvocationTargetException e) {
  35. throw new InternalError(e.toString());
  36. }
  37. }

Let’s go back to the getProxyClass method

Java code

  1. public static Class
    getProxyClass(ClassLoader loader,
  2. Class
    … interfaces)
  3. throws IllegalArgumentException
  4. {
  5. // Throw an exception if the target class implements more than 65535 interfaces.
  6. if (interfaces.length > 65535) {
  7. throw new IllegalArgumentException(“interface limit exceeded”);
  8. }
  10. // Declare the Class object represented by the proxy object.
  11. Class proxyClass = null;
  13. String[] interfaceNames = new String[interfaces.length];
  15. Set interfaceSet = new HashSet(); // for detecting duplicates
  17. // Iterate over the interface implemented by the target class
  18. for (int i = 0; i < interfaces.length; i++) {
  20. // Get the name of the interface implemented by the target class
  21. String interfaceName = interfaces[i].getName();
  22. Class interfaceClass = null;
  23. try {
  24. // Load the interface implemented by the target class into memory
  25. interfaceClass = Class.forName(interfaceName, false, loader);
  26. } catch (ClassNotFoundException e) {
  27. }
  28. if (interfaceClass ! = interfaces[i]) {
  29. throw new IllegalArgumentException(
  30. interfaces[i] + ” is not visible from class loader”);
  31. }
  33. // Omit some irrelevant code…….
  35. // Put the Class object represented by the interface implemented by the target Class into the Set
  36. interfaceSet.add(interfaceClass);
  38. interfaceNames[i] = interfaceName;
  39. }
  41. // Use the name of the interface implemented by the target class as the key in the cache (Map)
  42. Object key = Arrays.asList(interfaceNames);
  44. Map cache;
  46. synchronized (loaderToCache) {
  47. // Fetch the cache from the cache
  48. cache = (Map) loaderToCache.get(loader);
  49. if (cache == null) {
  50. // If not, create another HashMap instance
  51. cache = new HashMap();
  52. // Put the HashMap instance and the current loader in the cache
  53. loaderToCache.put(loader, cache);
  54. }
  56. }
  58. synchronized (cache) {
  60. do {
  61. // Retrieve objects from the cache based on the name of the interface
  62. Object value = cache.get(key);
  63. if (value instanceof Reference) {
  64. proxyClass = (Class) ((Reference) value).get();
  65. }
  66. if (proxyClass ! = null) {
  67. // If the Class instance of the proxy object already exists, it is returned directly
  68. return proxyClass;
  69. } else if (value == pendingGenerationMarker) {
  70. try {
  71. cache.wait();
  72. } catch (InterruptedException e) {
  73. }
  74. continue;
  75. } else {
  76. cache.put(key, pendingGenerationMarker);
  77. break;
  78. }
  79. } while (true);
  80. }
  82. try {
  83. // omit some code…….
  85. // This is the key to dynamically generating proxy objects
  86. byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  87. proxyName, interfaces);
  88. try {
  89. // Generate an instance of the proxy class based on its bytecode
  90. proxyClass = defineClass0(loader, proxyName,
  91. proxyClassFile, 0, proxyClassFile.length);
  92. } catch (ClassFormatError e) {
  93. throw new IllegalArgumentException(e.toString());
  94. }
  95. }
  96. // add to set of all generated proxy classes, for isProxyClass
  97. proxyClasses.put(proxyClass, null);
  99. }
  100. // omit some code…….
  102. return proxyClass;
  103. }

Go to the static method generateProxyClass of the ProxyGenerator class and this is where the bytecode of the proxy class is actually generated.

Java code

  1. public static byte[] generateProxyClass(final String name,
  2. Class[] interfaces)
  3. {
  4. ProxyGenerator gen = new ProxyGenerator(name, interfaces);
  5. // Generate the bytecode of the proxy class dynamically
  6. final byte[] classFile = gen.generateClassFile();
  8. // If the value of saveGeneratedFiles is true, the bytecode of the generated proxy class is saved to hard disk
  9. if (saveGeneratedFiles) {
  10. java.security.AccessController.doPrivileged(
  11. new java.security.PrivilegedAction<Void>() {
  12. public Void run() {
  13. try {
  14. FileOutputStream file =
  15. new FileOutputStream(dotToSlash(name) + “.class”);
  16. file.write(classFile);
  17. file.close();
  18. return null;
  19. } catch (IOException e) {
  20. throw new InternalError(
  21. “I/O exception saving generated file: ” + e);
  22. }
  23. }
  24. });
  25. }
  27. // Returns the bytecode of the proxy class
  28. return classFile;
  29. }

Now it’s clear how the JDK dynamically generates bytes of a proxy class. Now, there is another problem, which is who calls the Invoke method of InvocationHandler. The way to solve this problem is to look at what the JDK actually generates for us. Use the following code to get the bytecode generated by the JDK for us and write it to the hard disk.

Java code

  1. package dynamic.proxy;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  6. import sun.misc.ProxyGenerator;
  8. / * *
  9. * Proxy class generation tools
  10. * @author zyb
  11. * @since 2012-8-9
  12. * /
  13. public class ProxyGeneratorUtils {
  15. / * *
  16. * Writes the bytecode of the proxy class to hard disk
  17. * @param path Save path
  18. * /
  19. public static void writeProxyClassToHardDisk(String path) {
  20. // The first method is already known from the ProxyGenerator analysis
  21. // System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, true);
  23. // The second method
  25. // Get the bytecode of the proxy class
  26. byte[] classFile = ProxyGenerator.generateProxyClass(“$Proxy11”, UserServiceImpl.class.getInterfaces());
  28. FileOutputStream out = null;
  30. try {
  31. out = new FileOutputStream(path);
  32. out.write(classFile);
  33. out.flush();
  34. } catch (Exception e) {
  35. e.printStackTrace();
  36. } finally {
  37. try {
  38. out.close();
  39. } catch (IOException e) {
  40. e.printStackTrace();
  41. }
  42. }
  43. }
  44. }
  46. package dynamic.proxy;
  48. import org.junit.Test;
  50. / * *
  51. * Dynamic proxy test classes
  52. * @author zyb
  53. * @since 2012-8-9
  54. *
  55. * /
  56. public class ProxyTest {
  58. @Test
  59. public void testProxy() throws Throwable {
  60. // Instantiate the target object
  61. UserService userService = new UserServiceImpl();
  63. // Instantiate InvocationHandler
  64. MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
  66. // Generate a proxy object based on the target object
  67. UserService proxy = (UserService) invocationHandler.getProxy();
  69. // Call the method of the proxy object
  70. proxy.add();
  72. }
  74. @Test
  75. public void testGenerateProxyClass() {
  76. ProxyGeneratorUtils.writeProxyClassToHardDisk(“F:/$Proxy11.class”);
  77. }
  78. }

$proxy. class = $proxy. class = $proxy. class = $proxy. class = $proxy. class = $proxy. class = $proxy. class = $proxy. class

Java code

  1. // Decomcompiled by DJ V3.11.11.95 Copyright 2009 Atanas Neshkov Date: 2012/8/9 20:11:32
  2. // Home Page: http://members.fortunecity.com/neshkov/dj.html http://www.neshkov.com/dj.html – Check often for new version!
  3. // Decompiler options: packimports(3)
  5. import dynamic.proxy.UserService;
  6. import java.lang.reflect.*;
  8. public final class $Proxy11 extends Proxy
  9. implements UserService
  10. {
  12. // the constructor argument is an instance of the MyInvocationHandler class just passed in
  13. public $Proxy11(InvocationHandler invocationhandler)
  14. {
  15. super(invocationhandler);
  16. }
  18. public final boolean equals(Object obj)
  19. {
  20. try
  21. {
  22. return ((Boolean)super.h.invoke(this, m1, new Object[] {
  23. obj
  24. })).booleanValue();
  25. }
  26. catch(Error _ex) { }
  27. catch(Throwable throwable)
  28. {
  29. throw new UndeclaredThrowableException(throwable);
  30. }
  31. }
  33. / * *
  34. * This method is the key part
  35. * /
  36. public final void add()
  37. {
  38. try
  39. {
  40. MyInvocationHandler public Object Invoke (Object Proxy, Method Method, Object[] args)
  41. super.h.invoke(this, m3, null);
  42. return;
  43. }
  44. catch(Error _ex) { }
  45. catch(Throwable throwable)
  46. {
  47. throw new UndeclaredThrowableException(throwable);
  48. }
  49. }
  51. public final int hashCode()
  52. {
  53. try
  54. {
  55. return ((Integer)super.h.invoke(this, m0, null)).intValue();
  56. }
  57. catch(Error _ex) { }
  58. catch(Throwable throwable)
  59. {
  60. throw new UndeclaredThrowableException(throwable);
  61. }
  62. }
  64. public final String toString()
  65. {
  66. try
  67. {
  68. return (String)super.h.invoke(this, m2, null);
  69. }
  70. catch(Error _ex) { }
  71. catch(Throwable throwable)
  72. {
  73. throw new UndeclaredThrowableException(throwable);
  74. }
  75. }
  77. private static Method m1;
  78. private static Method m3;
  79. private static Method m0;
  80. private static Method m2;
  82. // Get four methods in static code block: Equals (Object), Add (UserService), hashCode (Object), toString (Object)
  83. static
  84. {
  85. try
  86. {
  87. m1 = Class.forName(“java.lang.Object”).getMethod(“equals”, new Class[] {
  88. Class.forName(“java.lang.Object”)
  89. });
  90. m3 = Class.forName(“dynamic.proxy.UserService”).getMethod(“add”, new Class[0]);
  91. m0 = Class.forName(“java.lang.Object”).getMethod(“hashCode”, new Class[0]);
  92. m2 = Class.forName(“java.lang.Object”).getMethod(“toString”, new Class[0]);
  93. }
  94. catch(NoSuchMethodException nosuchmethodexception)
  95. {
  96. throw new NoSuchMethodError(nosuchmethodexception.getMessage());
  97. }
  98. catch(ClassNotFoundException classnotfoundexception)
  99. {
  100. throw new NoClassDefFoundError(classnotfoundexception.getMessage());
  101. }
  102. }
  103. }




So far, the first two problems have been known, now use the JDK dynamic proxy will not only use, really achieve the purpose of “know what is, know why”…