Android 当中的 Fragment 协作解耦方式

Android 当中的 Fragment 协作解耦方式

文章目录

• [Android 当中的 Fragment 协作解耦方式](#Android 当中的 Fragment 协作解耦方式)
• • [第一章 前言介绍](#第一章 前言介绍)
  • • [第01节 遇到的问题](#第01节 遇到的问题)
    • [第02节 绘图说明](#第02节 绘图说明)
  • [第二章 核心代码](#第二章 核心代码)
  • • [第01节 代理人接口](#第01节 代理人接口)
    • [第02节 中间人 Activity](#第02节 中间人 Activity)
    • [第03节 开发者A](#第03节 开发者A)
    • [第04节 开发者B](#第04节 开发者B)
    • [第05节 测试类](#第05节 测试类)

第一章 前言介绍

第01节 遇到的问题

场景介绍:
	1、在同一个项目开发过程中, 程序员A 和 程序员B 开发着不同的功能模块。
	2、有一天需要程序员 A 和 程序员B 之间功能模块, 存在相互的调用关系。
	3、但是这些功能尚未开发完毕, 还在进行中。

问题来了:
	1、在未开发完毕之前, 如何实现相互之间能够调用呢?
	2、怎样才能保证功能的协作开发, 正确有效的完成呢?
	
试想场景:
	1、如果程序员 A 直接创建了 程序员B 开发类的对象, 调用程序员B 的方法。
	2、那么假设有一天程序员B 修改了其功能和操作, 那么程序员A 也被迫需要跟着修改。（依赖关系很强烈）

第02节 绘图说明

问题细节介绍

问题的解决方案

第二章 核心代码

为了简单直击问题点，我们采用 Java 代码去模拟 Android 的一些基础环境。

第01节 代理人接口

// 定义中间衔接的接口
public interface IServiceA2B {

    // 处理点击姓名的操作, 传递两个参数
    void handleClickName(int position, String message);

    // 处理点击头像的操作, 没有传递参数
    void handleClickAvert();
}

第02节 中间人 Activity

// 中间的 Activity 衔接人
public class Activity {

    // 在初始化 Activity 的 onCreate() 方法的时候, 初始化两个 Fragment
    private FragmentA fragmentA;
    private FragmentB fragmentB;

    public void onCreate(){
        // 初始化两个 Fragment
        fragmentA = new FragmentA();
        fragmentB = new FragmentB();

        // 两个Fragment 都会持有 Activity的对象
        fragmentA.onCreateView(this);
        fragmentB.onCreateView(this);
    }


    // 定义中间衔接的接口, 该接口采用内部类的方式实现, 便于统一管理。
    // 如果存在多个 FragmentA.FragmentB.FragmentC.FragmentD...
    // 可以分别实现不同的接口方式
    private final IServiceA2B serviceA2B = new IServiceA2B() {
        @Override
        public void handleClickName(int position, String message) {
            fragmentB.showName(position, message);
        }

        @Override
        public void handleClickAvert() {
            fragmentB.showAvert();
        }
    };

    // 暴露出接口对象, 给事件发起者, 持有该接口, 通过接口去调用具体的实现。
    public IServiceA2B getServiceA2B() {
        return serviceA2B;
    }
}

第03节 开发者A

事件的发起方。FragmentA

// 总结: 对于事件的发起者, FragmentA 需要做的三件事情:
// 1. 通过 Fragment 拿到 Activity 的对象。
// 2. 通过 Activity 的对象, 拿到代理接口的对象 service
// 3. 在处理点击事件的时候, 采用代理接口的对象, 去调用具体的方法
public class FragmentA {

    private Activity activity;

    public void onCreateView(Activity activity){
        System.out.println("FragmentA.onCreateView");
        this.activity = activity;

        buttonClickAvert();
        buttonClickName(66, "张无忌");
    }

    private void buttonClickName(int position, String name) {
        System.out.println("FragmentA.buttonClickName");
        activity.getServiceA2B().handleClickName(position, name);
    }

    private void buttonClickAvert() {
        System.out.println("FragmentA.buttonClickAvert");
        activity.getServiceA2B().handleClickAvert();
    }
}

第04节 开发者B

事件的接收方。FragmentB

// 总结: 对于事件的接收者, FragmentB 需要做的三件事情:
// 1. 自己的 Fragment 当中, 去定义接收到数据之后的实现展示的逻辑
// 2. 在外部定义需要衔接的接口, 代理接口 IServiceXXX
// 3. 在Activity 当中, 去定义接口的内部类实现。
//      I.  接口实现的方法当中, 采用 FragmentB 的对象, 去调用 FragmentB 当中的方法
//      II. 对外暴露出代理接口的对象, 也就是快捷键生产 getIServiceXXX 的对象, 让发送者持有代理接口对象。
public class FragmentB {

    private Activity activity;

    public void onCreateView(Activity activity){
        System.out.println("FragmentB.onCreateView");
        this.activity = activity;
    }

    public void showAvert() {
        System.out.println("FragmentB.showAvert");
    }

    public void showName(int position, String name) {
        System.out.println("FragmentB.showName.position: " + position +", name: " + name);
    }

}

第05节 测试类

模拟过程

public class Main {
    public static void main(String[] args) {
        System.out.println("APP启动了...");

        Activity activity = new Activity();
        activity.onCreate();

        System.out.println("APP退出了....");
    }
}

最终运行的结果

APP启动了...
FragmentA.onCreateView
FragmentA.buttonClickAvert
FragmentB.showAvert
FragmentA.buttonClickName
FragmentB.showName.position: 66, name: 张无忌
FragmentB.onCreateView
APP退出了....