See the strong insertion of AspectJ in Android

What is AOP

AOP is the abbreviation of Aspect Oriented Programming. It is a different idea from the OOP we usually come into contact with. OOP, or "object-oriented programming", advocates modularization and objectification of functions, while the idea of ​​AOP is different. It advocates unified processing of the same type of problems. Of course, in the actual programming process, we cannot simply use the ideas of AOP or OOP to program. In many cases, multiple programming ideas may be mixed. There is no need to worry about which idea to use. Taking the best of all schools is the right way.

So what is the use of AOP as a programming concept? Generally speaking, it is mainly used in scenarios where you do not want to invade the original code. For example, the SDK needs to insert some code into the host without intrusion to do logging, performance monitoring, dynamic permission control, and even code debugging.

AspectJ

AspectJ is actually a practice of AOP programming ideas. Of course, in addition to AspectJ, there are many other AOP implementations, such as ASMDex, but the most popular and convenient one is still AspectJ.

Using AspectJ in Android Projects

AOP is widely used, from Spring to Android, and is used everywhere, especially in the backend. It is very convenient to use in Spring and its functions are very powerful. However, in Android, the implementation of AspectJ is a slightly castrated version, and not all functions are supported. But for general client development, it is completely sufficient.

Integrating AspectJ on Android is actually quite complicated. It is not possible to compile it in one sentence. However, our company has solved this problem for you. Now you can use AspectJ in Android Studio very conveniently by using this SDK. The Github address is as follows:

https://github.com/HujiangTec…

Another successful library that uses AOP is Hugo by Jake:

https://github.com/JakeWharto…

Access Instructions

First, you need to add dependencies to the build.gradle file in the project root directory:

 classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:1.0.8'  

The complete code is as follows:

 buildscript {
 repositories {
 jcenter()
 }
 dependencies {
        classpath 'com.android.tools.build:gradle:2.3.0-beta2'  
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:1.0.8'   
 
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
 }
 }

Then add AspectJ dependency in the build.gradle of the main project or library:

 compile 'org.aspectj:aspectjrt:1.8.9'  

At the same time, add the AspectJX module to build.gradle:

 apply plugin: 'android-aspectjx'  

This completes the configuration of the AspectJ environment in the entire Android Studio. If you encounter errors such as "can't determine superclass of missing type xxxxx" during compilation, please refer to the project README for information about the use of excludeJarFilter.

 aspectjx {
    //includes the libs that you want to weave
    includeJarFilter 'universal-image-loader' , 'AspectJX-Demo/library'   
 
    //excludes the libs that you don't want to weave
    excludeJarFilter 'universal-image-loader'  
 }

Getting started with AspectJ

Let's use a simple code to understand the basic usage and functions. Create a new AspectTest class file with the following code:

 @Aspect
 public class AspectTest { 
 
    private static final String TAG = "xuyisheng" ; 
 
    @Before( "execution(* android.app.Activity.on**(..))" )
 public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
        String key = joinPoint.getSignature().toString();
        Log.d(TAG, "onActivityMethodBefore: " + key );
 }
 }

At the beginning of the class, we use the @Aspect annotation to define such an AspectJ file. The compiler will automatically parse it during compilation, and there is no need to actively call the code in the AspectJ class.

My original code was simple:

 public class MainActivity extends AppCompatActivity { 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 }
 }

After compiling in this way, let's take a look at what the generated code looks like. The principle of AspectJ is actually to parse according to certain rules during compilation, and then insert some code. The code generated by aspectjx will be in the Build directory:

Use the decompilation tool to view the generated content:

We can find that a line of AspectJ code is inserted at the beginning of onCreate. This is the main function of AspectJ. Putting aside the idea of ​​AOP, what we want to do is actually "add new code without invading the original code."

AspectJ Join Points

Join Points, or JPoints for short, is one of the core ideas of AspectJ. It is like a knife that cuts the entire execution process of a program into different parts. For example, constructor calls, method calls, method executions, exceptions, etc., are all Join Points. In fact, it is where you want to insert new code in the program, whether it is in the constructor, before a method call, or in a method. This place is the Join Point. Of course, not all places can be inserted for you. Only places that can be inserted are called Join Points.

AspectJ Pointcuts

The difference between Join Points and Pointcuts is actually difficult to explain, and I dare not say that my understanding is necessarily correct, but these are all conceptual content and do not affect our use.

Pointcuts, as I understand it, is actually to select the Join Points we need through certain conditions in Join Points. Therefore, Pointcuts, that is, Join Points with conditions, serve as the code entry points we need.

AspectJ Advice

Here comes another Advice. Advice is actually the most basic understanding, that is, the specific code we insert and how to insert it. The example we gave at the beginning used the simplest Advice - Before. Similar ones include After and Around. We will talk about their differences later.

AspectJ pointcut syntax

Let's take a look at the simplest AspectJ syntax with the previous Demo:

 @Before( "execution(* android.app.Activity.on**(..))" )
 public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
 }

This will be divided into several parts, let's look at them one by one:

• @Before: Advice, which is the specific insertion point
• execution: Processes the type of Join Point, such as call and execution
• ( android.app.Activity.on*(..)): This is the most important expression. The first '*' indicates the return value. '*' indicates that the return value is of any type. The following is a typical package name path, which can contain '*' for wildcarding. There is no difference between several '*'. At the same time, you can use '&&, ||, !' to combine conditions. () represents the parameters of this method. You can specify the type, such as android.os.Bundle, or (..) to represent any type and any number of parameters.
• public void onActivityMethodBefore: the actual entry code.

Here are some matching rules that can be used as examples to explain:

AspectJ Example

Before、After

These two Advices are probably the most commonly used, so let's take a look at the examples of these two Advices, starting with Before and After.

 @Before( "execution(* com.xys.aspectjxdemo.MainActivity.on*(android.os.Bundle))" )
 public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodBefore: " + key );
 } 
 
 @After ( "execution(* com.xys.aspectjxdemo.MainActivity.on*(android.os.Bundle))" )
 public void onActivityMethodAfter(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodAfter: " + key );
 }

After the above grammar explanation, it should be easy to understand now. Let's take a look at the compiled class:

We can see that based on the original code, the Before and After codes are added, and the Log can be correctly inserted and printed out.

Around

Before and After are actually quite easy to understand, that is, inserting code before and after Pointcuts. What about Around? From the literal meaning, it means inserting code before and after the method. Yes, it contains all the functions of Before and After. The code is as follows:

 @Around( "execution(* com.xys.aspectjxdemo.MainActivity.testAOP())" )
 public void onActivityMethodAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    String key = proceedingJoinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodAroundFirst: " + key );
    proceedingJoinPoint.proceed();
    Log.d(TAG, "onActivityMethodAroundSecond: " + key );
 }

Among them, proceedingJoinPoint.proceed() represents the execution of the original method. Various logical processing can be performed before and after this method.

Original code:

 public class MainActivity extends AppCompatActivity { 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 testAOP();
 } 
 
 public void testAOP() {
 Log.d( "xuyisheng" , "testAOP" );
 }
 }

Let's take a look at the compiled code first:

We can find that Around does implement the functions of Before and After, but it should be noted that Around and After cannot act on the same method at the same time, which will cause the problem of repeated entry.

Custom Pointcuts

Custom Pointcuts allow us to more accurately cut into one or more specified entry points.

First, we need to customize an annotation class, for example - DebugTool.java:

 /**
 * Custom AOP annotations
 * <p>
 * Created by xuyisheng on 17/1/12.
 */ 
 
 @Retention(RetentionPolicy.CLASS)
 @Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
 public @interface DebugTool {
 }

Then use this annotation where you need to insert the code:

 public class MainActivity extends AppCompatActivity { 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 testAOP();
 } 
 
 @DebugTool
 public void testAOP() {
 Log.d( "xuyisheng" , "testAOP" );
 }
 }

***, let's create our own entry file.

 @Pointcut( "execution(@com.xys.aspectjxdemo.DebugTool * *(..))" )
 public void DebugToolMethod() {
 } 
 
 @Before( "DebugToolMethod()" )
 public void onDebugToolMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onDebugToolMethodBefore: " + key );
 }

First define Pointcut and declare the method name to be monitored, then add the entry code in Before or other Advice to complete the entry.

The compiled code is as follows:

In this way, we can easily monitor the specified Pointcut, thereby increasing the granularity of monitoring.

call and execution

In the AspectJ pointcut expression, we have used execution before. In fact, there is another type - call. So what is the difference between these two syntaxes? Let's try it out and we will know.

The cut code is still very simple:

 public class MainActivity extends AppCompatActivity { 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 testAOP();
 } 
 
 public void testAOP() {
 Log.d( "xuyisheng" , "testAOP" );
 }
 }

Let's look at execution first. The code is as follows:

 @Before( "execution(* com.xys.aspectjxdemo.MainActivity.testAOP(..))" )
 public void methodAOPTest(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "methodAOPTest: " + key );
 }

The compiled code is as follows:

Let's look at the call again. The code is as follows:

 @Before( "call(* com.xys.aspectjxdemo.MainActivity.testAOP(..))" )
 public void methodAOPTest(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "methodAOPTest: " + key );
 }

The compiled code is as follows:

In fact, it is clear at a glance when you compare them. Execution is in the method being cut into, and call is before or after calling the method being cut into.

For Call:

 Call (Before)
 Pointcut
 Pointcut Method
 }
 Call ( After )

For Execution:

 Pointcut
 execution（Before）
 Pointcut Method
 execution（ After ）
 }

Pointcut filtering and withincode

In addition to the call and execution mentioned above, there is also a more commonly used withincode. This syntax is usually used to filter some entry point conditions for more precise entry control. We can refer to the following example:

 public class MainActivity extends AppCompatActivity { 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 testAOP1();
 testAOP2();
 } 
 
 public void testAOP() {
 Log.d( "xuyisheng" , "testAOP" );
 } 
 
 public void testAOP1() {
 testAOP();
 } 
 
 public void testAOP2() {
 testAOP();
 }
 }

Both testAOP1() and testAOP2() call the testAOP() method. However, if we want to enter the code only when the testAOP2() method calls the testAOP() method, we need to use a combination of Pointcut and withincode to accurately locate the entry point.

 // In the testAOP2() method
 @Pointcut( "withincode(* com.xys.aspectjxdemo.MainActivity.testAOP2(..))" )
 public void invokeAOP2() {
 } 
 
 // When calling the testAOP() method
 @Pointcut( "call(* com.xys.aspectjxdemo.MainActivity.testAOP(..))" )
 public void invokeAOP() {
 } 
 
 // The previous conditions are met at the same time, that is, the testAOP() method is called in the testAOP2() method.
 @Pointcut( "invokeAOP() && invokeAOP2()" )
 public void invokeAOPOnlyInAOP2() {
 } 
 
 @Before( "invokeAOPOnlyInAOP2()" )
 public void beforeInvokeAOPOnlyInAOP2(JoinPoint joinPoint) {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onDebugToolMethodBefore: " + key );
 }

Let's look at the compiled code again:

We can see that the code is inserted only in the testAOP2() method, which achieves precise conditional insertion.

Exception handling AfterThrowing

AfterThrowing is a relatively rare advice, which is used to handle unhandled exceptions in the program. Remember, this is very important, it is an unhandled exception. The specific reason will be known after we look at the decompiled code. Let's write an exception casually, the code is as follows:

 public void testAOP() {
 View   view = null ;
 view .animate();
 }

Then use AfterThrowing to write AOP code:

 @AfterThrowing(pointcut = "execution(* com.xys.aspectjxdemo.*.*(..))" , throwing = "exception" )
 public void catchExceptionMethod(Exception exception) {
    String message = exception.toString();
    Log.d(TAG, "catchExceptionMethod: " + message);
 }

This code is very simple. It also uses a similar expression as before, but here we use *.* for wildcarding to handle exceptions. In the exception, we execute a line of log. The compiled code is as follows:

We can see that all methods under the com.xys.aspectjxdemo package have been added with try catch. At the same time, the code we cut into has been inserted in the catch. However, it will still throw e, that is, the exception has been thrown and the crash will still occur. At the same time, if your original code has already tried catch, it will also fail to handle. For the specific reason, let's look at a decompiled code:

As you can see, in fact, there is another layer of try catch in the catch of the original code, so when e.printStackTrace() is try caught, no more exceptions will occur and it will be impossible to cut in.

AspectJX Use Cases

At present, many projects of our company have used this AOP solution, such as AOP-based dynamic permission management, AOP-based business data tracking, AOP-based performance monitoring system, etc.

Now a part of the source code of dynamic permission management based on AOP has been open sourced, but because of the need to separate the business code, this function code will be further improved later. You can continue to pay attention to it. The github address is as follows:

https://github.com/firefly112…

Other AOP projects are being open sourced one after another, so you can continue to pay attention~