架构之AOP面向切面架构设计

架构之AOP面向切面思想之集中式登陆架构设计

1. AOP简介：

AOP为Aspect Oriented Programming全称，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续…来自百度百科

2. 利用 AOP可以做什么呢？

aop可以对业务逻辑各个部分进行分离，从而可以是业务逻辑各个部分之间的耦合度降低，提高程序的可重用性。

3. AOP面向切面架构设计-两种方式

1. 方式一：开发中，需要对View进行判空处理，当View不为空，才能调用该控件方法，如TextView的setText()等，否则会报空指针。面向切面的思想在这里表现为：将所有的判空处理使用动态代理去执行，相当于将判空动作横向切面

2. 方式二：应用中有许多Activity，现在需要对每个Activity的生命周期进行监听（动态换肤案例）。 google已经给我们提供了一个面向切面的思想和API，如下代码：

   关于aop在android源码的应用，在Application注册监听Activity的生命周期，采用的就是面向切面编程的思想。
   案例操作流程：在MainActivity点击view 跳转到SecondActivity，然后退出栈，并查看log日志。

   class MyApplication : Application() {
       override fun onCreate() {
           super.onCreate()
           Log.e(TAG, "onCreate: ")
           registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
               override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
                   Log.e(TAG, "onActivityCreated: ")
                   // 进行换肤操作
               }
   
               override fun onActivityStarted(activity: Activity) {}
               override fun onActivityResumed(activity: Activity) {}
               override fun onActivityPaused(activity: Activity) {}
               override fun onActivityStopped(activity: Activity) {}
               override fun onActivitySaveInstanceState(aactivity: Activity, outState: Bundle) {}
               override fun onActivityDestroyed(activity: Activity) {
                   Log.e(TAG, "onActivityDestroyed: ")
               }
           })
       }
   
       companion object {
           private val TAG = MyApplication::class.java.simpleName
       }
   }
   

   输出结果：

   07-16 09:15:45.514 10815-10815/com.purang.skin E/MyApplication: onCreate: 
   07-16 09:15:45.557 10815-10815/com.purang.skin E/MyApplication: onActivityCreated: 
   07-16 09:15:45.669 10815-10815/com.purang.skin E/MainActivity: onCreate: 
   07-16 09:15:50.181 10815-10815/com.purang.skin E/MyApplication: onActivityCreated: 
   07-16 09:15:50.187 10815-10815/com.purang.skin E/SecondActivity: onCreate: 
   07-16 09:15:52.545 10815-10815/com.purang.skin E/MyApplication: onActivityDestroyed: 
   07-16 09:15:52.546 10815-10815/com.purang.skin E/SecondActivity: onDestroy: 
   07-16 09:16:01.247 10815-10815/com.purang.skin E/MyApplication: onActivityDestroyed: 
   07-16 09:16:01.247 10815-10815/com.purang.skin E/MainActivity: onDestroy: 
   

4. 如何理解AOP面向切面架构设计？

在平时开发中绝大部分都是横向切面，把需要抽取的相同业务功能抽取出来，做成一个切面。如在ATM上做取款，查询，转账等项目，都需要做一个验证用户的操作。

实际上，AOP本质是一系列纵向的业务流程中，把那些具有相同业务的子流程抽取成一个横向的面

5. 案例：AOP面向切面-动态代理需求

1. 开发项目中，碰到的真实案例：本地sqlite数据库进行增删改的时候，每一次操作之前，都要做一次数据的备份，如下流程图：

2. 代码体现方式：运行时通过动态代理的方式来切面

3. 代码实现

1. 常规实现方式：

   public class MainActivity extends AppCompatActivity implements DBOperation{
   @Override
   protected void onCreate(Bundle savedInstanceState) {
   	// 实例化
       dbOperation = this;
   }
   
   // 调用
   @Override
   public void insert() {
       dbOperation.save();
       dbOperation.insert();
   }
   // 调用
   @Override
   public void delete() {
       dbOperation.save();
       dbOperation.delete();
   }
   

2. 运行时动态代理的方式来实现。
   运行时动态代理的方式，做了个切面，

   public class MainActivity extends AppCompatActivity implements DBOperation{
       private DBOperation dbOperation;
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
   
           dbOperation = (DBOperation) Proxy.newProxyInstance(DBOperation.class.getClassLoader(), new Class[]{DBOperation.class}, new DBHandler(this));
       }
   
       public void insert(View view) {
           dbOperation.insert();
       }
   
       public void delete(View view) {
           dbOperation.delete();
       }
   
       public void update(View view) {
           dbOperation.update();
       }
   
   
       private class DBHandler implements InvocationHandler {
           DBOperation dbOperation;
           public DBHandler(DBOperation  db) {
               dbOperation = db;
           }
   
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               if (dbOperation != null) {
                   Log.e("TAG", "操作数据库之前，开始备份数据库 ");
                   save();
                   Log.e("TAG", "数据库备份完成后，等待后续操作...");
                   return method.invoke(dbOperation, args);
               }
               return null;
           }
       }
   
       public void jump(View view) {
           startActivity(new Intent(MainActivity.this, OrderActivity.class));
       }
   
       @Override
       public void insert() {
           Log.e("TAG", "insert ");
       }
   
       @Override
       public void delete() {
           Log.e("TAG", "delete");
       }
   
       @Override
       public void update() {
           Log.e("TAG", "update");
       }
   
       @Override
       public void query() {
   
       }
   
       @Override
       public void save() {
           Log.e("TAG", "备份数据...");
       }
   }
   

   输出结果：

   2020-01-29 17:54:53.494 9260-9260/com.example.aop E/TAG: 操作数据库之前，开始备份数据库 
   2020-01-29 17:54:53.494 9260-9260/com.example.aop E/TAG: 备份数据...
   2020-01-29 17:54:53.494 9260-9260/com.example.aop E/TAG: 数据库备份完成后，等待后续操作...
   2020-01-29 17:54:53.494 9260-9260/com.example.aop E/TAG: insert 
   2020-01-29 17:54:56.367 9260-9260/com.example.aop E/TAG: 操作数据库之前，开始备份数据库 
   2020-01-29 17:54:56.367 9260-9260/com.example.aop E/TAG: 备份数据...
   2020-01-29 17:54:56.367 9260-9260/com.example.aop E/TAG: 数据库备份完成后，等待后续操作...
   2020-01-29 17:54:56.367 9260-9260/com.example.aop E/TAG: delete
   2020-01-29 17:55:04.560 9260-9260/com.example.aop E/TAG: 操作数据库之前，开始备份数据库 
   2020-01-29 17:55:04.560 9260-9260/com.example.aop E/TAG: 备份数据...
   2020-01-29 17:55:04.560 9260-9260/com.example.aop E/TAG: 数据库备份完成后，等待后续操作...
   2020-01-29 17:55:04.560 9260-9260/com.example.aop E/TAG: update
   

3. 预编译期的AOP技术实现，详见：集中式登陆架构设计

本文地址：https://blog.csdn.net/weixin_35937808/article/details/103543408