Shulou(Shulou.com)05/31 Report--

Most people do not understand the knowledge points of this article "how to achieve faceted programming in Android", so the editor summarizes the following content, detailed content, clear steps, and has a certain reference value. I hope you can get something after reading this article. Let's take a look at this "how to achieve faceted programming in Android" article.

Install AspectJ

ApsectJ development on Android consists of several parts, AspectJ gradle plug-ins, ApsectJ dependencies, and AspectJ compilers.

Installing the AspectJ compiler first is easy, just like installing the JAVA environment

At present, the latest one has been updated to 1.9.1. If your computer already has a JAVA environment, just run this jar package directly.

After installation, you need to configure the environment variables to the bin directory of aspectj, which will not be discussed here.

Export PATH= "$PATH:~/Library/Android/sdk/platform-tools" export PATH= "$PATH:/usr/local/opt/gradle/gradle-4.1/bin" export PATH= "$PATH:~/Library/Android/sdk/ndk-bundle" export PATH= "$PATH:~/Library/flutter/bin" export PATH= "$PATH:~/Library/kotlinc/bin" export PATH= "$PATH:~/Library/AspectJ/bin" if (! variant.buildType.isDebuggable ()) {log.debug ("Skipping non-debuggable" Build type'${variant.buildType.name}'. ") Return } JavaCompile javaCompile = variant.javaCompile javaCompile.doLast {String [] args = ["- showWeaveInfo", "- 1.8", "- inpath", javaCompile.destinationDir.toString (), "- aspectpath", javaCompile.classpath.asPath, "- d", javaCompile.destinationDir.toString (), "- classpath", javaCompile.classpath.asPath, "- bootclasspath" Project.android.bootClasspath.join (File.pathSeparator)] MessageHandler handler = new MessageHandler (true) New Main () .run (args, handler);}} / /-add content

This gradle script is the compilation process of adding an acj after the completion of java compilation.

MessageHandler is an object in AspectJ Tools that is used to receive parameters and then compile with acj.

Finally, add dependencies dependency and support for AspectJ.

Implementation 'org.aspectj:aspectjrt:1.9.0'

Create AspectJ code

The following part of the code will look confused, but don't worry about the specific grammatical meaning for now.

First run the environment, and then combined with the theory to slowly modify the code to feel that you can quickly start AOP.

Take a HelloWorld as an example, our MainActivity does nothing but a basic lifecycle approach.

Public class MainActivity extends AppCompatActivity {@ Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main);} @ Override protected void onStart () {super.onStart ();} @ Override protected void onPause () {super.onPause ();} @ Override protected void onStop () {super.onStop ();} @ Override protected void onDestroy () {super.onDestroy ();}

Now we're going to write an AspectJ class that looks a little different from a normal Java class, which can be understood as simply using annotations as a medium to let the ACJ compiler know which methods to inject.

What this class does is tell the ACJ compiler to print a line of log in front of each method in MainActivity, outputting which method is currently executed

@ Aspectpublic class AspectTest {private static final String TAG = "AspectTest"; @ Pointcut ("execution (* phoenix.com.helloaspectj.MainActivity.** (..)") Public void executeAspectJ () {} @ Before ("executeAspectJ ()") public void beforeAspectJ (JoinPoint joinPoint) throws Throwable {Log.d (TAG, "beforeAspectJ: injected->" + joinPoint.toShortString ());}}

When I first came into contact with AspectJ, I was a little confused when I saw this code. Explain the meaning of several annotations.

Aspect: tell the ACJ compiler that this is an AspectJ class

@ PointCut: PointCut is a concept in AspectJ, and another concept along with it is JoinPoint, which together describes the aspect to be injected.

@ Before: indicates the location to be injected. The common ones are Before/After/Around, which means before execution, after execution, and replacing the original method, respectively.

Here, the @ PointCut annotated parameter means to inject all the methods in MainActivity, and the parameter uses regular matching syntax.

Let's take a look at the result of this code execution.

07-26 16-04-56.611-22823-22823? D/AspectTest: beforeAspectJ: injected-> execution (MainActivity.onCreate (..)

07-26 16-04-56.661-22823-22823? D/AspectTest: beforeAspectJ: injected-> execution (MainActivity.onStart ())

We see that although we didn't write the log print statement in MainActivity, we did it through AspectJ, inserting our own log before the two lifecycles of MainActivity were executed.

The above is about the content of this article on "how to achieve faceted programming in Android". I believe we all have a certain understanding. I hope the content shared by the editor will be helpful to you. If you want to know more related knowledge, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.