Aspect-Oriented Programming (AOP) and Its Application in Android Client Development

Common programming architecture concepts include Object Oriented Programming (OOP), Procedure Oriented Programming (POP) and Aspect Oriented Programming (AOP). OOP and POP are familiar to most developers, while AOP is less commonly used; this article provides a brief analysis of AOP in client‑side development.

Aspect Oriented Programming (AOP)

AOP (Aspect Oriented Programming) is a technique that uses pre‑compilation and runtime dynamic proxies to achieve unified maintenance of program functionality.

It is an extension of OOP, a hot topic in software development and a derivative paradigm of functional programming. By isolating different parts of business logic, AOP reduces coupling, improves reusability and development efficiency.

Conceptually, AOP adds code vertically into objects, like a knife that slices a process at defined join points, making the whole flow clearer.

Classification and Common Concepts

AOP can be divided into two categories: runtime AOP (e.g., Java dynamic proxy) and compile‑time AOP (e.g., ASM, AspectJ). For mobile clients, compile‑time AOP is preferred to minimise runtime overhead.

Typical AOP concepts include: Joinpoint, Pointcut, Advice, Target, Introduction, Weaving, Proxy, Aspect.

Application in Mobile Client Development

While AOP is mature in backend frameworks such as Spring, its use in client development is still emerging. The article explores how to integrate AOP ideas to improve Android client development efficiency.

Hot Fix (Hot‑Fix)

Two years ago hot‑fix technology became popular. NetEase News adopted an AOP‑based hot‑fix solution. The principle is to modify Java bytecode at compile time, instrumenting each method so that a patch can be hooked at method level.

AOP Framework Selection

Many compile‑time AOP frameworks exist (ASM, AspectJ, Javassist). AspectJ was chosen for its low learning curve and perfect Java support.

Android Hot‑Fix Implementation – Key Points

1. Method‑level hook: after Java compilation and before dex generation, AspectJ weaves code that injects a lookup for a patch method. If a patch exists, it is executed; otherwise the original logic runs.

public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
    try {
        String e = joinPoint.toLongString(); //获取当前方法的签名
        PatchDebug.printMethodDesByFile(e);
        if (PatchUtils.hasMethodPatch(e)) { //查询是否有自己方法的patch方法
            Object target = joinPoint.getTarget(); //获取当前的运行对象，方便设置给patch方法
            Object[] params = joinPoint.getArgs(); //获取运行参数
            //省略一些处理逻辑
            return joinPoint.proceed(); //执行原有逻辑
        }
    } catch (Exception var8) {
        var8.printStackTrace();
    }
    return joinPoint.proceed();
}

2. When and how to weave: the weaving time is after Java source compilation and before dex generation. Two approaches are possible:

a) Hook the Java compiler task and run AspectJ’s compiler directly.

project.android.applicationVariants.all { variant ->
    if (variant.buildType.name != "release") {
        log.debug("Skipping non-release build type '${variant.buildType.name}'.")
        return;
    }
    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        //执行aspectJ编译操作
        String[] args = ["-showWeaveInfo",
                         "-1.5",
                         "-inpath", javaCompile.destinationDir.toString(),
                         "-aspectpath", javaCompile.classpath.asPath,
                         "-d", javaCompile.destinationDir.toString(),
                         "-classpath", javaCompile.classpath.asPath,
                         "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
        log.debug "ajc args: " + Arrays.toString(args)
        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler);
    }
}

b) Use the Gradle Transform API (recommended). This API, introduced after Android Gradle Plugin 1.5, allows uniform bytecode modification before dex generation and works better with third‑party libraries.

Patch Package Generation

When a bug is found, the affected method is placed into a dedicated class, compiled into an APK that contains only that class. Using the release mapping file, unnecessary classes and resources are stripped to keep the patch package minimal.

Patch Loading and Execution

At runtime, the patch APK is loaded via DexFile.loadDex(). Patch methods are cached by signature; each method checks the cache before execution and runs the patch if present.

Advantages and Disadvantages

Advantages

Disadvantages

No compatibility issues

Increased method count and APK size

Real‑time effect

Longer release build time

Small patch package

Runtime performance impact

Performance Impact

Method‑level overhead is measured in milliseconds; overall startup time may increase by about 500 ms.

Optimization Strategies

a) Use a lighter AOP framework to reduce size and impact. b) Adopt class‑level hot‑fix solutions.

Automation Tools

• Method execution‑time monitoring: hook each method with AspectJ, log warnings when main‑thread methods exceed a threshold. • Automatic logging: hook Activity/Fragment lifecycle methods to record user behavior. • Third‑party SDK detection/modification: monitor SDK method latency, apply temporary hooks for quick mitigation, capture SDK network and behavior logs. • Click debounce: globally hook android.view.View.OnClickListener#onClick(View) to prevent rapid repeated clicks.

Application Performance Monitoring (APM)

Using AOP, a non‑intrusive performance monitoring platform was built to track network latency, UI interaction times, and other metrics, enabling optimisations such as HttpDNS and CDN improvements.

AOP vs. APT

APT (Annotation Processing Tool) processes annotations at compile time, generating .java files that are later compiled to .class. AOP modifies .class files directly after compilation, inserting or altering code logic.

Author

Wang Guangcong – Joined NetEase Media client team in 2016, technical expert responsible for Android client architecture design, performance optimisation, and hot‑fix development.