设计模式之《代理模式》

什么是代理模式

代理模式是一种结构型的设计模式，它允许在不改变原有代码的情况下，通过增加一个代理来控制对原有对象的访问。简而言之，代理模式就是将一个对象的操作交给另一个对象来完成，这个过程隐藏了真实的对象，使得客户端只需要与代理对象交互。

为什么用代理模式

在实际开发中，我们常常会需要对某个对象进行限制或增强，但是又不想对这个对象进行修改或扩展。这时候，使用代理模式就可以很好地解决这个问题。通过代理对象，我们可以隐藏掉真实对象的实现细节，同时也可以对真实对象进行控制。

工作中用在哪里

在Android开发中，代理模式也被广泛地应用。比如，我们可以使用代理模式来控制对某个Activity的访问，以实现Activity权限的控制；还可以使用代理模式来封装网络请求，从而控制请求流量和请求频率；同时，代理模式也可以用来实现事件回调机制。

设计思路

代理模式的设计思路比较简单，我们只需要在原有对象的基础上增加一个代理即可。代理对象持有一个对真实对象的引用，同时也实现了与真实对象相同的接口。当客户端需要访问真实对象时，先通过代理对象进行访问，代理对象再将请求转发给真实对象。

代码实现

下面我们通过一个具体的例子来演示代理模式的实现。在这个例子中，我们将使用代理模式来实现Activity权限的控制。
首先，我们定义一个Activity接口，用于定义Activity的基本行为：

public interface Activity {
    void onCreate(Bundle savedInstanceState);
    void onStart();
    void onResume();
    void onPause();
    void onStop();
    void onDestroy();
}

然后，我们定义一个真实的Activity，它实现了Activity接口中定义的所有方法：

public class RealActivity implements Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        Log.i("RealActivity", "onCreate");
    }

    @Override
    public void onStart() {
        Log.i("RealActivity", "onStart");
    }

    @Override
    public void onResume() {
        Log.i("RealActivity", "onResume");
    }

    @Override
    public void onPause() {
        Log.i("RealActivity", "onPause");
    }

    @Override
    public void onStop() {
        Log.i("RealActivity", "onStop");
    }

    @Override
    public void onDestroy() {
        Log.i("RealActivity", "onDestroy");
    }
}

接下来，我们定义一个代理对象，它持有一个对真实Activity的引用。在代理对象中，我们可以对真实Activity进行权限控制，从而控制对Activity的访问：

public class ProxyActivity implements Activity {
    private RealActivity realActivity;

    public ProxyActivity(RealActivity realActivity) {
        this.realActivity = realActivity;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        if (checkPermission("create")) {
            realActivity.onCreate(savedInstanceState);
        }
    }

    @Override
    public void onStart() {
        if (checkPermission("start")) {
            realActivity.onStart();
        }
    }

    @Override
    public void onResume() {
        if (checkPermission("resume")) {
            realActivity.onResume();
        }
    }

    @Override
    public void onPause() {
        if (checkPermission("pause")) {
            realActivity.onPause();
        }
    }

    @Override
    public void onStop() {
        if (checkPermission("stop")) {
            realActivity.onStop();
        }
    }

    @Override
    public void onDestroy() {
        if (checkPermission("destroy")) {
            realActivity.onDestroy();
        }
    }

    private boolean checkPermission(String permission) {
        // 这里可以进行权限控制，比如根据用户角色判断是否有权限访问
        return true;
    }
}

最后，我们可以通过代理对象来访问真实Activity：

Activity activity = new ProxyActivity(new RealActivity());
activity.onCreate(null);  // 输出 "onCreate"
activity.onStart();       // 输出 "onStart"
activity.onResume();      // 输出 "onResume"
activity.onPause();       // 输出 "onPause"
activity.onStop();        // 输出 "onStop"
activity.onDestroy();     // 输出 "onDestroy"

Android中的Retrofit的代理模式

Retrofit是一个强大的网络请求库，在网络请求过程中使用了代理模式来实现接口的动态代理。

以下是Retrofit中代理模式的简化示例代码：

创建一个网络请求的接口ApiService：

interface ApiService {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String): Call<List<Repo>>
}

使用Retrofit创建动态代理接口的实例：

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build()

val apiService = retrofit.create(ApiService::class.java)

在上述代码中，Retrofit使用动态代理来实现ApiService接口的实例化。调用retrofit.create(ApiService::class.java)时，Retrofit会生成一个代理对象，该代理对象会拦截接口方法的调用，并将请求转发给真正的网络请求执行者。

总结

代理模式是一种很常见的设计模式，它允许在不修改原有代码的情况下，控制对某个对象的访问。在Android开发中，代理模式也被广泛应用，比如实现Activity权限控制、封装网络请求、实现事件回调等。掌握代理模式可以让我们更好地设计和组织代码，提高系统的可维护性和可扩展性。