Interviewer asked: What is a dynamic proxy?

[[439196]]

This article is reprinted from the WeChat public account "Java Geek Technology", the author is Tang, a fan of Yaxue. Please contact the Java Geek Technology public account for reprinting this article.

1. Introduction

What is an agent?

According to historical records, the word "agent" first appeared in the agency industry. In short, the so-called agent helps companies or bosses to manage their business, and does not produce any goods themselves.

For example, when we go to the train station to buy tickets, if there are few people, the boss can handle it alone, but if there are many people, it will be very crowded, so there are various ticket sales points, and we can buy tickets from the ticket sales points, which speeds up the boss's ticket sales.

The emergence of ticket sales outlets can be said to have directly helped bosses improve users' ticket purchasing experience.

From the perspective of software design, the effect is actually the same. Using proxy mode programming can significantly enhance the original functions and simplify method calling.

Before introducing dynamic proxy, let's talk about static proxy first.

2. Static Proxy

Next, we take the addition of two numbers as an example, the implementation process is as follows!

Interface Class

 public interface Calculator { 
 
 /**
 * Calculate the sum of two numbers
 * @param num1
 * @param num2
 * @return  
 */
 Integer   add ( Integer num1, Integer num2);
 }

Target audience

 public class CalculatorImpl implements Calculator { 
 
 
 @Override
 public   Integer   add ( Integer num1, Integer num2) {
 Integer result = num1 + num2;
 return result;
 }
 }

Proxy Object

 public class CalculatorProxyImpl implements Calculator { 
 
 
    private Calculator calculator; 
 
 
 @Override
 public   Integer   add ( Integer num1, Integer num2) {
 //Before calling the method, you can add other functions....
 Integer result = calculator. add (num1, num2);
 //After the method is called, other functions can be added....
 return result;
 } 
 
 
 public CalculatorProxyImpl(Calculator calculator) {
        this.calculator = calculator;
 }
 }

Test Class

 public class CalculatorProxyClient { 
 
 public   static void main(String[] args) {
 //Target object
        Calculator target = new CalculatorImpl();
 //Proxy object
        Calculator proxy = new CalculatorProxyImpl(target);
 Integer result = proxy.add ( 1,2);
 System. out .println( "Addition result: " + result);
 }
 }

Output

 Added result: 3

The biggest advantage of this proxy method is that the function of the target object can be extended without modifying the target object.

But there are also disadvantages: the proxy object and the target object need to implement the same interface. Therefore, when the target object expands new functions, the proxy object must also be expanded, which is not easy to maintain!

3. Dynamic Proxy

Dynamic proxy is actually created to solve the pain point that when the target object expands new functions, the proxy object also needs to expand along with it.

So how is it solved?

Taking JDK as an example, when it is necessary to add proxy processing to a target object, JDK will dynamically build a proxy object in memory to implement the proxy function for the target object.

Next, we will take the addition of two numbers as an example to introduce the specific gameplay!

3.1. How to generate proxy objects in JDK

Creating an interface

 public interface JdkCalculator { 
 
 /**
 * Calculate the sum of two numbers
 * @param num1
 * @param num2
 * @return  
 */
 Integer   add ( Integer num1, Integer num2);
 }

Target audience

 public class JdkCalculatorImpl implements JdkCalculator { 
 
 @Override
 public   Integer   add ( Integer num1, Integer num2) {
 Integer result = num1 + num2;
 return result;
 }
 }

Dynamic Proxy Objects

 public class JdkProxyFactory { 
 
 /**
 * Maintain a target object
 */
 private Object target; 
 
 public JdkProxyFactory(Object target) {
 this.target = target;
 } 
 
 public Object getProxyInstance(){
        Object proxyClassObj = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler(){ 
 
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 System. out .println( "Before calling the method, you can add other functions...." ); 
 
 // Execute the target object method
                        Object returnValue = method.invoke(target, args);
 System. out .println( "After the method is called, other functions can be added...." );
 return returnValue;
 }
 });
 return proxyClassObj;
 }
 }

Test Class

 public class TestJdkProxy { 
 
 public   static void main(String[] args) {
 //Target object
        JdkCalculator target = new JdkCalculatorImpl();
        System. out .println(target.getClass());
 //Proxy object
        JdkCalculator proxyClassObj = (JdkCalculator) new JdkProxyFactory(target).getProxyInstance();
        System. out .println(proxyClassObj.getClass());
 //Execute the proxy method
 Integer result = proxyClassObj.add (1,2) ;
 System. out .println( "Addition result: " + result);
 }
 }

Output

 class com.example.java.proxy.jdk1.JdkCalculatorImpl
 class com.sun.proxy.$Proxy0
 Before the method is called, you can add other functions....
 After the method is called, you can add other functions....
 Added result: 3

The steps to dynamically create an interface instance using JDK technology are as follows:

 1. First, define an InvocationHandler instance, which is responsible for implementing the method call of the interface
 2. Create an interface instance through Proxy.newProxyInstance(), which requires 3 parameters:
 (1) The ClassLoader used is usually the ClassLoader of the interface class
 (2) An array of interfaces that need to be implemented, at least one interface needs to be passed in;
 (3) An InvocationHandler instance used to process interface method calls.
 3. Cast the returned Object to an interface

Dynamic proxy is actually the process of JVM dynamically creating and loading class bytecode at runtime. It does not involve any black magic technology. Rewriting the above dynamic proxy into a static implementation class probably looks like this:

 public class JdkCalculatorDynamicProxy implements JdkCalculator { 
 
    private InvocationHandler handler; 
 
 public JdkCalculatorDynamicProxy(InvocationHandler handler) {
        this.handler = handler;
 } 
 
 public void add ( Integer num1, Integer num2) {
 handler.invoke(
 this,
           JdkCalculator.class.getMethod( "add" , Integer .class, Integer .class),
           new Object[] { num1, num2 });
 }
 }

The essence is that JVM automatically writes the above class for us (no source code is required, bytecode can be generated directly).

3.2. How to use cglib to generate proxy objects

In addition to JDK's ability to dynamically create proxy objects, there is also a very famous third-party framework: cglib, which can also dynamically generate a subclass object in memory at runtime to expand the functionality of the target object.

cglib features are as follows:

cglib can not only proxy interfaces but also classes, while JDK's dynamic proxy can only proxy interfaces.

cglib is a powerful, high-performance code generation package that is widely used by many AOP frameworks, such as the well-known Spring AOP, for which cglib provides method interception.

The underlying layer of the CGLIB package uses a small and fast bytecode processing framework ASM to convert bytecode and generate new classes at a very fast speed.

Before using cglib, we need to add dependency packages. If you already have the spring-core jar package, you do not need to introduce it because cglib is included in spring.

 <dependency>
 <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
 <version>3.2.5</version>
 </dependency>

Next, we will take the addition of two numbers as an example to introduce the specific gameplay!

 public interface CglibCalculator { 
 
 /**
 * Calculate the sum of two numbers
 * @param num1
 * @param num2
 * @return  
 */
 Integer   add ( Integer num1, Integer num2);
 }

Target audience

 public class CglibCalculatorImpl implements CglibCalculator { 
 
 
 @Override
 public   Integer   add ( Integer num1, Integer num2) {
 Integer result = num1 + num2;
 return result;
 }
 }

Dynamic Proxy Objects

 public class CglibProxyFactory implements MethodInterceptor { 
 
 /**
 * Maintain a target object
 */
 private Object target; 
 
 public CglibProxyFactory(Object target) {
 this.target = target;
 } 
 
 /**
 * Generate a proxy object for the target object
 * @return  
 */
 public Object getProxyInstance() {
 //Tools
        Enhancer en = new Enhancer();
 //Set the parent class
        en.setSuperclass(target.getClass());
 //Set callback function
 en.setCallback(this);
 //Create a subclass object proxy
 return en.create () ;
 } 
 
 @Override
 public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 System. out .println( "Before calling the method, you can add other functions...." ); 
 
 // Execute the target object method
        Object returnValue = method.invoke(target, args);
 System. out .println( "After the method is called, other functions can be added...." );
 return returnValue;
 }
 }

Test Class

 public class TestCglibProxy { 
 
 public   static void main(String[] args) {
 //Target object
        CglibCalculator target = new CglibCalculatorImpl();
        System. out .println(target.getClass());
 //Proxy object
        CglibCalculator proxyClassObj = (CglibCalculator) new CglibProxyFactory(target).getProxyInstance();
        System. out .println(proxyClassObj.getClass());
 //Execute the proxy method
 Integer result = proxyClassObj.add (1,2) ;
 System. out .println( "Addition result: " + result);
 }
 }

Output

 class com.example.java.proxy.cglib1.CglibCalculatorImpl
 class com.example.java.proxy.cglib1.CglibCalculatorImpl$$EnhancerByCGLIB$$3ceadfe4
 Before the method is called, you can add other functions....
 After the method is called, you can add other functions....
 Added result: 3

Rewriting the proxy class generated by cglib into a static implementation class might look like this:

 public class CglibCalculatorImplByCGLIB extends CglibCalculatorImpl implements Factory { 
     
 
    private static final MethodInterceptor methodInterceptor; 
 
    private static final Method method; 
         
 
 public final Integer   add ( Integer var1, Integer var2) {
 return methodInterceptor.intercept(this, method, new Object[]{var1, var2}, methodProxy);
 } 
 
 //....
 }

Among them, the interception idea is similar to JDK, and both are intercepted through an interface method!

As we have mentioned above, cglib can not only proxy interfaces but also proxy classes. Now let’s try proxying classes.

 public class CglibCalculatorClass { 
 
 /**
 * Calculate the sum of two numbers
 * @param num1
 * @param num2
 * @return  
 */
 public   Integer   add ( Integer num1, Integer num2) {
 Integer result = num1 + num2;
 return result;
 }
 }

Test Class

 public class TestCglibProxyClass { 
 
 public   static void main(String[] args) {
 //Target object
        CglibCalculatorClass target = new CglibCalculatorClass();
        System. out .println(target.getClass());
 //Proxy object
        CglibCalculatorClass proxyClassObj = (CglibCalculatorClass) new CglibProxyFactory(target).getProxyInstance();
        System. out .println(proxyClassObj.getClass());
 //Execute the proxy method
 Integer result = proxyClassObj.add (1,2) ;
 System. out .println( "Addition result: " + result);
 }
 }

Output

 class com.example.java.proxy.cglib1.CglibCalculatorClass
 class com.example.java.proxy.cglib1.CglibCalculatorClass$$EnhancerByCGLIB$$e68ff36c
 Before the method is called, you can add other functions....
 After the method is called, you can add other functions....
 Added result: 3

4. Static Weaving

In the above, the proxy solutions we introduced all dynamically generate class files when the code is running to achieve the purpose of dynamic proxy.

Back to the essence of the problem, in fact, the technical purpose of dynamic proxy is mainly to solve the problem that when the target interface is expanded in the static proxy mode, the proxy class must also be changed accordingly, so as to avoid the tediousness and complexity of work.

In the Java ecosystem, there is also a very famous third-party proxy framework, which is AspectJ. AspectJ can compile the target class into class bytecode through a specific compiler, and add business logic around the method to achieve the effect of static proxy.

There are four main methods for method implantation using AspectJ:

• Intercept before method call
• Intercept after method call
• Call method to end interception
• Throwing exception interception

It is also very simple to use. The first step is to add the AspectJ compiler plug-in to the project.

 <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
 <version>1.5</version>
 <executions>
 <execution>
 <goals>
                <goal>compile</goal>
                <goal>test-compile</goal>
 </goals>
 </execution>
 </executions>
 <configuration>
 <source>1.6</source>
 <target>1.6</target>
        <encoding>UTF-8</encoding>
        <complianceLevel>1.6</complianceLevel>
        <verbose> true </verbose>
        <showWeaveInfo> true </showWeaveInfo>
 </configuration>
 </plugin>

Then, write a method to prepare for the proxy.

 @RequestMapping({ "/hello" })
 public String hello(String name ) {
    String result = "Hello World" ;
    System. out .println(result);
 return result;
 }

Writing a proxy configuration class

 @Aspect
 public class ControllerAspect { 
 
 /***
 * Define the entry point
 */
    @Pointcut( "execution(* com.example.demo.web..*.*(..))" )
 public void methodAspect(){} 
 
 /**
 * Intercept before method call
 */
    @Before( "methodAspect()" )
 public void before(){
 System.out.println ( "Proxy->Before calling method execution......" ) ;
 } 
 
 /**
 * Intercept after method call
 */
    @After ( "methodAspect()" )
 public void after (){
 System.out.println ( "Proxy->After calling method execution......" ) ;
 } 
 
 /**
 * Call method to end interception
 */
    @AfterReturning( "methodAspect()" )
 public void afterReturning(){
 System. out .println( "Proxy -> After calling the method... " );
 } 
 
 /**
 * Throw exception interception
 */
    @AfterThrowing( "methodAspect()" )
 public void afterThrowing() {
 System. out .println( "Proxy -> Call method exception......" );
 }
 }

After compilation, the hello method will become like this.

 @RequestMapping({ "/hello" })
 public String hello( Integer   name ) throws SQLException {
    JoinPoint var2 = Factory.makeJP(ajc$tjp_0, this, this, name ); 
 
 Object var7;
 try {
 Object var5;
 try {
 //Call before
            Aspectj.aspectOf().doBeforeTask2(var2);
            String result = "Hello World" ;
            System. out .println(result);
 var5 = result;
        } catch (Throwable var8) {
            Aspectj.aspectOf(). after (var2);
 throw var8;
 }
 //Call after  
        Aspectj.aspectOf(). after (var2);
 var7 = var5;
    } catch (Throwable var9) {
 //Call throws an exception
        Aspectj.aspectOf().afterthrowing(var2);
 throw var9;
 }
 //Call return  
    Aspectj.aspectOf().afterRutuen(var2);
 return (String)var7;
 }

Obviously, the code has been modified by the AspectJ compiler. AspectJ does not dynamically generate proxy classes at runtime, but instead embeds the code into the class file during compilation.

Because it is statically woven, the performance is relatively good!

V. Summary

Seeing the static weaving scheme introduced above, it is very similar to the way we use Spring AOP now. Some students may wonder, is the Spring AOP dynamic proxy we are using now dynamically generated or statically woven?

In fact, Spring AOP proxy is a layer of encapsulation of JDK proxy and CGLIB proxy, and introduces some annotations in AspectJ such as @pointCut, @after, @before, etc., which essentially uses dynamic proxy technology.

To sum up, there are three points:

If the target is an interface, JDK's dynamic proxy technology is used by default;

If the target is a class, use cglib's dynamic proxy technology;

Some annotations in AspectJ, such as @pointCut, @after, and @before, are introduced, mainly to simplify usage and have little to do with AspectJ.

So why doesn't Spring AOP use a static weaving solution like AspectJ?

Although the AspectJ compiler is very powerful and has very high performance, it needs to be recompiled as long as the target class is modified. The main reason may be that the AspectJ compiler is too complicated and is not as worry-free as dynamic proxy!

6. Reference

1. Three Java proxy modes: static proxy, dynamic proxy and cglib proxy

2. What is the role of Java dynamic proxy?