Preface
In the Java world, JDK's dynamic proxy is a very powerful and practical technology that provides us with the possibility of dynamically creating proxy classes at runtime, thereby enabling flexible interception and enhancement of target object method calls. Today, let’s explore all aspects of JDK dynamic proxy together.
1. What is JDK dynamic proxy
JDK's dynamic proxy is a technical means implemented based on the Java reflection mechanism. Simply put, it can dynamically generate a proxy class during the program's run, which implements the same interface as our target object. Inside the proxy class method, the corresponding method of the target object will be called, and we can insert the logical code defined by ourselves before and after the target method is called, thus achieving interception and functional enhancement of the target method.
For example, it's like we have a star (target object), and the agent class is like a star's agent. If fans (callers) want to communicate with celebrities (call methods), they need to go through the broker. Agents can ask fans some questions (pre-logic) before they communicate with celebrities, and after the communication, they can also make some summary (post-logic) but in fact, the stars (target object execution method) are actually communicating with fans.
From a Java language perspective, dynamic proxy allows developers to create a proxy class instance at runtime that implements a specified interface that forwards method calls to a specified target object and executes additional logic before and after forwarding. This allows us to enhance or modify the behavior of its method without modifying the target object code, providing great flexibility for program design and maintenance.
2. The principle of JDK dynamic proxy
The core principle of JDK dynamic proxy is Java's reflection mechanism. Reflection allows us to obtain information about the class at runtime, including methods, fields, etc., and be able to call methods and operate fields dynamically.
In dynamic proxy, when we useProxyClassicnewProxyInstanceWhen creating a proxy object, JDK will do the following things at the bottom:
- Generate proxy class bytecode: JDK will dynamically generate the bytecode of a proxy class based on the interface implemented by the target object we pass in. This process involves analyzing and processing the methods defined in the interface, generating corresponding proxy logic for each method. The bytecode of the proxy class is generated at runtime through a special bytecode generation algorithm. It implements the same interface as the target object and contains pairs within each method.
InvocationHandlercall logic. - Loading proxy class: Use the specified class loader to load the generated proxy class bytecode into the JVM, making it a usable class. The class loader plays a key role in this process, and it is responsible for converting the bytecode into a class object that the JVM can understand and process. Different class loaders may cause proxy classes to load in different namespaces, which is very important for handling issues such as isolation and security of classes.
- Create a proxy object: Create an instance of the proxy class through the reflection mechanism, and implement it
InvocationHandlerThe instance is passed to the proxy object. thisInvocationHandlerAn instance is like the "brain" of a proxy object, which determines how the proxy object should handle it when receiving a method call. The proxy object will be created whenInvocationHandlerSave the instance so that the correct method can be called when calledinvokemethod.
When the method of the proxy object is called, it is actually calledInvocationHandlerImplement the class in theinvokemethod. existinvokeIn the method, we can call the target object's method by reflection, and we can add our own logic before and after the call. Specifically,invokeThe method receives three parameters: the proxy object itself, the called method object, and the method parameter list. Through these parameters, we can obtain detailed information about method calls and process them as needed.
3. Steps to use JDK dynamic proxy
3.1 Defining an interface
First, we need to define an interface that defines the method signature of the target object. Both the target object and the proxy object need to implement this interface. This is like setting a set of specifications for both stars (target objects) and brokers (agent objects) to do things (methods).
For example:
interface HelloWorld {
void sayHello();
}In this interface, we define asayHellomethod, it has no parameters and no return value. This method is the method we will operate in the target object and the proxy object in the future.
3.2 Create a target object
Create a target object class that implements the above interface. This class is the object we are actually going to be proxyed, which contains the real business logic, that is, what the stars need to do.
class HelloWorldImpl implements HelloWorld {
@Override
public void sayHello() {
("Hello, World!");
}
}existHelloWorldImplIn the class, we implementedHelloWorldInterfacesayHelloMethod, when this method is called, it outputs "Hello, World!" in the console. This is the core business logic of the target object.
3.3 Create InvocationHandler implementation class
Create a class implementationInvocationHandlerInterface, ininvokeThe interception and processing logic of the target method is realized in the method. This class is like a broker's workbook, telling the broker what to do when facing different situations (method calls).
class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
= target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
("Before method invocation");
Object result = (target, args);
("After method invocation");
return result;
}
}existMyInvocationHandlerIn the class, we first receive a target object through the constructor, and theninvokeIn the method, we can see that before calling the target method, the output "Before method invocation" is first output, and then the(target, args)The target object method is called, and the reflection mechanism is used here to call the target object method to ensure that the target object's business logic can be correctly executed. Finally, after the call, "After method invocation" is output. In this way, we can insert our own logical code before and after the target method call to achieve enhancement of the target method.
3.4 Create a proxy object
useProxyClassicnewProxyInstanceMethod creates a proxy object. This method is like a magic factory that generates proxy objects based on the information we provide.
HelloWorld proxy = (HelloWorld) (
().getClassLoader(),
().getInterfaces(),
handler
);Here we pass in the target object class loader, the interface array implemented by the target object, andInvocationHandlerImplement an instance of the class.The method will dynamically create a proxy object based on these parameters, and this proxy object is implementedHelloWorldInterface, and internally associated with theMyInvocationHandlerExample.
3.5 Calling proxy object method
Calling methods through proxy objects will actually callInvocationHandlerImplement the class in theinvokeMethods, we can decide whether to call the target object's method in this method and execute some additional logic before and after the call.
();
When we call()When it is executed firstMyInvocationHandlerIn-houseinvokeThe pre-logic logic in the method, and then the target object'ssayHelloMethod, and finally execute post-logic logic. In the console, we will see that "Before method invocation" is output first, then "Hello, World!" is output finally "After method invocation".
4. Application scenarios of JDK dynamic proxy
4.1AOP (sectional-oriented programming)
In AOP, dynamic proxy is an important means to implement sectional logic. For example, if we want to add logging functions to multiple different business methods, we can use dynamic proxy. Through the proxy, the logic of logging is inserted before and after the method call is not modified without modifying the target object code, which realizes the separation of business logic and logging logic, and improves the maintainability and scalability of the code.
For example, we have a user management system that includes multiple business methods such as adding users, deleting users, and modifying users. We can use the JDK dynamic proxy to add logging functions to these methods, recording the call time, parameters, and return values of each method. In this way, when problems arise, we can easily troubleshoot problems through logging without manually adding logging code in each business method.
4.2 Remote Agent
When we need to access remote objects, such as calling services on the remote server, we can use dynamic proxy to create a local proxy object. This proxy object is like a local "representative", responsible for communicating with the remote object, converting our local method calls into a method calls on the remote server, and returning the result to us. For us callers, it is like we are calling a local object, and we do not feel the complexity of remote calls.
For example, our application needs to call a remote weather forecast service to obtain weather information for a certain city. We can use dynamic proxy to create a local proxy object that implements the same interface as the remote weather forecast service. When we call the proxy object's method locally, the proxy object sends the request to the remote server, gets the weather information, and returns the result to us. This way, we can easily use remote services without caring about the details of remote calls.
4.3 Delayed loading
Sometimes, we may not want to load all objects when the program starts, but instead hope to load its specific implementation only when the object is actually used. At this time, the dynamic proxy can play a role. We can implement lazy loading logic in proxy objects, and only create the actual target object when calling related methods. This can improve the performance and resource utilization of the system and avoid unnecessary waste of resources.
For example, in a large enterprise-level application, there may be many modules and objects. Some objects do not need to be used immediately when the program starts, but if all objects are loaded at startup, it will cause too long to start and occupy a large amount of memory resources. We can use dynamic proxy to proxy these objects, and only load their specific implementations when the methods of these objects are actually called, thereby improving the performance and response speed of the system.
4.4 Transaction Management
Transaction management is a very important part of database operations. We can use JDK dynamic proxy to implement transaction management of database operation methods. Through the proxy, the transaction is started before the method call, the transaction is submitted after the method call is successful, and the transaction is rolled back when an exception occurs in the method call. This ensures the consistency and integrity of database operations and avoids data inconsistencies.
For example, in a bank transfer system, we have a transfer method that requires transaction management before and after the transfer operation. We can use dynamic proxy to add transaction management logic to the transfer method to ensure that the transfer operation is either successful or all fails, and there will be no partial success or partial failure, ensuring data consistency.
5. Limitations of JDK dynamic proxy
5.1 Only proxy interfaces
JDK dynamic proxy requires that the target object must implement an interface because the proxy class proxys the target object by implementing the same interface. If our target object does not implement an interface, then it is impossible to use JDK dynamic proxy. It's like our stars (target objects) do not do things according to the prescribed specifications (interfaces), and the broker (agent class) doesn't know how to proxy.
For example, if we have a concrete class that does not implement any interfaceSomeClass, we cannot directly use JDK dynamic proxy to create proxy objects for it. In this case, we may need to consider using other proxy technologies, such as CGLIB proxy, which can proxy classes that do not implement interfaces.
5.2 Cannot proxy final method
Due to JavafinalThe method cannot be rewritten, so the JDK dynamic proxy cannot use the target objectfinalMethods are proxied and intercepted. It's like there's something about a star (target object) (finalMethods) must not be interfered with or changed by others, and brokers (agents) cannot perform additional operations on these things.
For example, in the target object class there is afinalmethodfinalMethod, When we use JDK dynamic proxy to create a proxy object, call thisfinalMethodWhen a method is used, the proxy object cannot intercept and enhance it, but directly calls the target object'sfinalMethodmethod. This is becausefinalThe nature of the method determines that it cannot be rewritten, while JDK dynamic proxy implements proxy logic by rewriting interface methods.
6. Comparison with other agent technologies
In Java, in addition to JDK dynamic proxy, there are other proxy technologies, such as CGLIB proxy and Javassist proxy. These proxy technologies have their own characteristics. Compared with JDK dynamic proxy, there are mainly some differences:
- CGLIB proxy: CGLIB proxy implements proxy by inheriting the target class, and it does not require the target class to implement interfaces. This allows CGLIB proxy to proxy classes that do not implement interfaces, making up for the limitation that JDK dynamic proxy can only proxy interfaces. However, since the CGLIB proxy is implemented through inheritance, it cannot be correct
finalClass andfinalMethods are proxyed. - Javassist proxy: Javassist is a bytecode operation library that can dynamically generate and modify the bytecode of Java classes at runtime. The Javassist proxy can implement proxy logic by modifying the bytecode of the target class. It is more flexible and can provide more fine-grained control of classes and methods. However, the use of Javassist proxy is relatively complicated and requires a certain understanding of bytecode operations.
Compared with these proxy technologies, the advantage of JDK dynamic proxy is that it is a Java native proxy technology, does not require the introduction of additional dependency libraries, and is simple and easy to use in terms of proxy interfaces. However, in the face of classes that cannot implement interfaces, it is necessary tofinalWhen performing proxying, other proxy technologies need to be considered.
The above is the detailed content of the in-depth understanding and practical application of JDK dynamic proxy. For more information about JDK dynamic proxy, please pay attention to my other related articles!