Tagged articles
Javassist
25 articles · Page 1 of 1
This article provides a comprehensive technical guide covering Java bytecode structure, the seven-stage class lifecycle, JIT compilation, memory layout, garbage‑collection algorithms, execution engine details, and both static and dynamic bytecode enhancement techniques such as ASM, Javassist, and Java agents.
ASMClass LoadingJIT
0 likes · 74 min read

This article explains how Java agents work, compares premain and attach agents, shows how to implement entry points, use Instrumentation and Javassist to transform bytecode, provides complete code samples, packaging instructions, and demonstrates the runtime output with diagrams.
AgentAttachJava
0 likes · 17 min read

This article explains the concept of Java Agent, compares it with AOP, and provides step‑by‑step implementations of both premain and agentmain modes, including Maven packaging, VM attachment, class transformation, redefinition, retransformation, and a Javassist example for method timing.
AgentmainBytecode ManipulationJava Agent
0 likes · 17 min read

This article demonstrates how to use Spring's ApplicationContextInitializer together with Javassist to intercept class loading in a Spring Cloud environment, modify the bytecode of org.apache.commons.lang3.RandomStringUtils, and record method calls, handling parent‑child container initialization nuances.
AOPBytecode ManipulationJava
0 likes · 5 min read

This article explains the principles and implementation of a Java RPC framework, covering service registration with Zookeeper, serialization, compression, network communication via Netty, dynamic proxy generation using reflection and Javassist, and performance considerations, providing extensive code examples for each component.
JavaJavassistNetty
0 likes · 25 min read

This article walks through building a simple Java RPC framework, covering core concepts such as service registration with Zookeeper, client-side dynamic proxies, network communication via Netty, serialization, compression, and both reflection and Javassist-based proxy generation, complete with code examples and performance comparisons.
JavaJavassistNetty
0 likes · 26 min read

This article explains the principles of Interactive Application Security Testing (IAST), details the JavaAgent-based agent instrumentation approach, and provides a step‑by‑step guide to building a Java IAST agent using Javassist, custom class loaders, ThreadLocal tracing, and Maven packaging.
Application SecurityIASTJavaAgent
0 likes · 13 min read

This article explains the fundamentals of Remote Procedure Call (RPC), covering its definition, core challenges, service registration and discovery with Zookeeper, client proxy generation, network transmission using Netty, serialization and compression, server-side request handling via reflection or Javassist, and performance comparisons between proxy strategies.
JavaJavassistNetty
0 likes · 24 min read

This article introduces Java Agent technology, explains the differences between premain and agentmain modes, demonstrates how to build, package, and attach agents using Maven and the Attach API, and shows practical bytecode manipulation techniques with Instrumentation and Javassist, complete with code examples.
AgentBackendJava
0 likes · 20 min read


JavaEdgeFeb 27, 2023 · Backend Development
This article explains the core principle of RPC using dynamic proxies, showing how interfaces are proxied at runtime, the code generation process, and compares JDK, Javassist, and Byte Buddy proxy implementations with practical examples.
BackendByte BuddyJDK Proxy
0 likes · 9 min read

This article walks through the design and implementation of a lightweight Java RPC framework, covering core concepts such as service registration and discovery with Zookeeper, network communication via Netty, serialization, compression, dynamic proxy generation using Javassist, and performance comparisons between reflection and bytecode‑generated proxies.
JavaJavassistNetty
0 likes · 23 min read

This article explains the principles and implementation of a lightweight Java RPC framework, covering service registration with Zookeeper, client-side dynamic proxies, serialization, compression, Netty-based network transport, and both reflection and Javassist proxy generation, with extensive code examples and performance comparison.
JavaJavassistNetty
0 likes · 25 min read


JD TechJul 27, 2022 · Backend Development
This article explains the Java parent‑delegation model, shows how to implement a custom ClassLoader for class hot‑swap and jar hot‑deployment, demonstrates Java SPI for dynamic service loading, and details building a plugin framework using Java Agent and Javassist for runtime bytecode enhancement.
ClassLoaderHotSwapJavaAgent
0 likes · 30 min read

This article explains the core concepts and implementation steps of a lightweight Java RPC framework, covering RPC definition, service registration and discovery with Zookeeper, client-side dynamic proxies, network transmission using Netty, serialization, compression, and two server‑side proxy generation strategies (reflection and Javassist).
JavaJavassistNetty
0 likes · 25 min read

This article explains how to create a static analysis tool that scans Android APKs for privacy‑sensitive API calls, covering both compile‑time bytecode instrumentation and runtime stack tracing, with step‑by‑step instructions, code examples, configuration details, and optimization techniques.
APK ScanningAndroidJavassist
0 likes · 13 min read

This article explains Java's proxy pattern, compares static and dynamic proxies, and provides detailed examples of JDK dynamic proxy, CGLIB, Javassist, and ASM implementations, highlighting their mechanisms, code samples, and practical considerations for backend development.
ASMBackendCGLIB
0 likes · 21 min read

This article explains the proxy pattern in Java, compares static and dynamic proxy implementations, provides complete code examples for JDK dynamic proxies, CGLIB, Javassist, and ASM proxies, and discusses their characteristics, performance considerations, and practical usage scenarios.
ASMCGLIBJDK
0 likes · 21 min read

The article explains how to enhance Java bytecode using a javaagent, covering bytecode fundamentals, agent loading during JVM startup, implementation steps, transformation via ClassFileTransformer, and popular tools such as ASM, Javassist, and ByteBuddy for non‑intrusive runtime instrumentation and monitoring.
AOPASMByteBuddy
0 likes · 13 min read

This article explains Java bytecode fundamentals, its file structure, and demonstrates how to manipulate and enhance bytecode at runtime using ASM, Javassist, the Instrumentation API, JVMTI agents, and the Attach API, providing practical code examples and use‑case scenarios.
ASMAgentJava
0 likes · 28 min read

This article explains Java bytecode fundamentals, its class‑file layout, constant‑pool details, and then walks through practical bytecode‑enhancement techniques using ASM, Javassist, and the Instrument API to modify and reload classes at runtime for AOP, hot‑deployment and monitoring purposes.
ASMAgentJava
0 likes · 28 min read

The article explains how analyzing Java bytecode with tools such as Javassist during the Android Gradle transform phase yields precise, method‑level module dependency data—overcoming the limitations of Gradle trees, import scans, and IDE analysis—and provides a reliable way to map and enforce clean dependency structures in large Android codebases.
AndroidJavaJavassist
0 likes · 10 min read

This article explains the JavaAgent feature introduced after JDK 1.5, its reliance on JVMTI and JPLISAgent, how to write premain classes and class file transformers, the role of MANIFEST.MF, and analyzes conflicts between Javassist‑based and ByteBuddy‑based agents when they modify the same class.
ByteBuddyJVMJVMTI
0 likes · 17 min read


转转QAJun 13, 2018 · Backend Development
The article introduces a Java‑based log instrumentation tool that leverages AOP and the Javassist library to transparently capture interface input, output, and performance metrics, enabling richer test case generation, mock creation, and long‑term performance monitoring for backend services.
AOPJavassistPerformance Monitoring
0 likes · 5 min read

This article analyzes the challenges of mocking Dubbo services in large‑scale Java projects, explores multiple design options—including generic service registration, Javassist proxies, and custom reference implementations—compares their pros and cons, and presents the final architecture that enables dynamic registration, method‑level mocking, and transparent fallback to real services.
DubboGeneric ServiceJava
0 likes · 30 min read

This article demonstrates how to employ Java's java.lang.instrument API together with Javassist to create a Java agent that instruments bytecode at runtime, enabling performance monitoring without modifying the original application code.
AgentClassFileTransformerJava
0 likes · 6 min read
