Reflectasm framework and Java dynamic agency study
Reflectasm framework and Java dynamic agency study
introduction:
In Java development, dynamic proxy is a powerful technology that allows us to generate proxy objects at runtime to intercept and enhance the method call.The standard method of the Java dynamic proxy is to use Java.lang.reflet.proxy, but there are other alternatives, such as the Reflectasm framework.This article will compare the REFLECTASM framework with the Java dynamic proxy to better understand their differences and applications.
1. Overview of Java dynamic agency
The Java dynamic proxy is a technology that uses the proxy class to create proxy objects. It is used to intercept and enhance the method call by implementing the InvoCationHandler interface.Through dynamic proxy, we can provide additional functions to the agent objects during runtime, such as log records, performance analysis, transaction management, etc.The following is an example of using Java dynamic proxy:
public interface UserService {
void addUser(String username, String password);
void deleteUser(String username);
}
public class UserServiceImpl implements UserService {
@Override
public void addUser(String username, String password) {
System.out.println("Add user: " + username);
}
@Override
public void deleteUser(String username) {
System.out.println("Delete user: " + username);
}
}
public class LogProxy implements InvocationHandler {
private final Object target;
public LogProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Method " + method.getName() + " is called");
return method.invoke(target, args);
}
}
public class Main {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(),
new LogProxy(userService)
);
proxy.addUser("Alice", "pass123");
proxy.deleteUser("Bob");
}
}
In the above examples, we define an interface `userService` and its implementation class` UserServiceImpl`.The `LogProxy` class implements the InvoCATIONHANDLER interface to intercept and enhance method calls.In the `Main` class, we use the` Proxy.newproxyinstance` method to create an agent object `proxy` and use it as the` userService` type.
2. Overview of Reflectasm Framework
Reflectasm is a low -level API -based operation -based operation. It provides a faster and flexible way to generate class objects.Its core idea is to generate proxy by directly accessing bytecode files, rather than reflecting the API.Reflectasm has a high performance and is suitable for frequent calls for agent objects.The following is an example of using Reflectasm:
public interface UserService {
void addUser(String username, String password);
void deleteUser(String username);
}
public class UserServiceImpl implements UserService {
@Override
public void addUser(String username, String password) {
System.out.println("Add user: " + username);
}
@Override
public void deleteUser(String username) {
System.out.println("Delete user: " + username);
}
}
public class ReflectASMProxyFactory {
public static UserService createProxy(UserService target) throws Exception {
ClassReader classReader = new ClassReader(UserService.class.getName());
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
String proxyClassName = UserService.class.getName() + "Proxy";
ClassVisitor classVisitor = new ClassVisitor(Opcodes.ASM5, classWriter) {
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
if (name.equals("addUser") && desc.equals("(Ljava/lang/String;Ljava/lang/String;)V")) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
return new MethodVisitor(Opcodes.ASM5, mv) {
@Override
public void visitCode() {
super.visitCode();
visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
visitLdcInsn("Method addUser is called");
visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
}
};
}
return super.visitMethod(access, name, desc, signature, exceptions);
}
};
classReader.accept(classVisitor, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG);
byte[] proxyClassBytes = classWriter.toByteArray();
Class<?> proxyClass = new ASMClassLoader().defineClass(proxyClassName, proxyClassBytes);
Constructor<?> constructor = proxyClass.getConstructor(UserService.class);
return (UserService) constructor.newInstance(target);
}
}
public class Main {
public static void main(String[] args) throws Exception {
UserService userService = new UserServiceImpl();
UserService proxy = ReflectASMProxyFactory.createProxy(userService);
proxy.addUser("Alice", "pass123");
proxy.deleteUser("Bob");
}
}
In the above examples, we define the same interface and implementation class as the Java dynamic proxy examples.`Reflectasmproxyfactory` Class provides a static method for creating proxy objects` createdProxy`.In this method, we use the REFLECTASM API to generate the byte code of the proxy class and enhance the `adduser` method.Then, the proxy class is loaded into the memory through the customized `ASMCLASSSLOADER`, and uses reflex to instantiate the proxy object.
3. Comparison of Reflectasm and Java dynamic agent
In the following aspects, we compared the REFLECTASM framework and the Java dynamic agent:
1. Performance:
ReflectASM's performance is usually higher than Java dynamic agents.Because it is directly operated by the byte code to achieve proxy generation and method calls, avoiding performance loss caused by reflection.Especially in the absence of frequent calls for proxy objects, the advantage of Reflectasm is more obvious.
2. Flexibility:
Java dynamic proxy uses standard reflex APIs, which can act as an agent that implements a class that implements interfaces.However, it cannot proxy the class that does not implement the interface.Reflectasm can represent any class, including classes that do not implement interfaces.This makes Reflectasm more flexible in some special circumstances.
3. Readability:
Java dynamic proxy uses standard interface+implementation class. The code readability is better, easy to understand and maintain.ReflectASM generates the proxy class through bytecode operation. The code readability is poor, and you need to be familiar with the ASM framework to use it.
Based on the above comparison, we can draw the following conclusions:
-If the need for a class that already has interfaces and does not have high requirements for performance, you can use Java dynamic proxy.
-If the need to proxy a class that does not implement interfaces or has high performance requirements, you can consider using the ReflectASM framework.
in conclusion:
The Reflectasm framework and the Java dynamic agent each have different advantages and applications.Developers can choose suitable technologies according to specific needs to achieve dynamic proxy, and weigh the houses in terms of performance, flexibility and readability.
references:
-RFLECTASM github home
-ASM framework official website: https: //asm.ow2.io/
