Android开发设计模式之代理模式实现思路_android by 代理

代理模式是一种结构型设计模式，可以允许通过代理对象控制对其他对象的访问，代理对象充当了目标对象的中介，客户端通过代理对象访问目标对象，能够实现在不改变目标对象的前提之下，控制或者拓展对象的行为 。

---

代理模式

代理模式细分可以划分为如下三种：

• 静态代理：这是最简单的代理模式，要求代理类和真实类实现相同的接口，并且代理类中只包含了一个真实类的实例。客户端代码通过调用代理类的方法时，代理类会对其进行一些处理，然后调用真实类的方法进行实际的操作。

下面给出静态代理的实现代码：

public interface ISubject {
    void request();
}

public class RealSubject implements ISubject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

public class Proxy implements ISubject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("Proxy: Logging before requesting.");
        realSubject.request();
        System.out.println("Proxy: Logging after requesting.");
    }
}

// 在使用时，我们可以这样调用：
RealSubject realSubject = new RealSubject();
Proxy proxy = new Proxy(realSubject);
proxy.request();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在代码中，定义了一个ISubject 接口，一个RealSubject类，实现了接口；然后定义了一个Proxy 类，实现了ISubject 接口，并且在实现request方法，先输出日志，然后调用RealSubject 的request方法，最后在输出日志，能够实现在不改变原始类的情况下，添加额外的功能。

• 动态代理：这是一种更为灵活的代理模式，不要求代理类或者真实类实现同样的接口，而是利用java的反射机制实现运行时动态生成代理对象，动态代理通常涉及到一个innovationHandler接口，以及一个Proxy类生成对象。

---

Android开发中使用静态代理

在Android中使用代理模式时，静态代理是最简单的实现方式之一。给出代码演示了如何使用静态代理来实现权限控制：

首先，定义一个接口IUserManager，它将被代理类和真实类实现：

public interface IUserManager {
    void addUser(String name, String password);
}
1
2
3

然后，定义一个真实类UserManager，它实现了IUserManager接口：

public class UserManager implements IUserManager {
    @Override
    public void addUser(String name, String password) {
        // 添加用户的业务逻辑
    }
}
1
2
3
4
5
6

接下来，定义一个代理类UserProxy，它也实现了IUserManager接口，并且包含一个真实类UserManager的实例：

public class UserProxy implements IUserManager {
    private IUserManager userManager;

    public UserProxy(IUserManager userManager) {
        this.userManager = userManager;
    }

    @Override
    public void addUser(String name, String password) {
        // 在添加用户之前，进行权限校验
        if (checkPermission()) {
            userManager.addUser(name, password);
        } else {
            throw new RuntimeException("无权限进行该操作");
        }
    }

    private boolean checkPermission() {
        // 校验用户权限的业务逻辑
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个代理类中，实现了addUser方法并在其中进行了权限校验。如果校验通过，则调用真实类UserManager的addUser方法，否则抛出一个运行时异常。

最后，在使用时，可以这样来创建代理对象并调用其方法：

IUserManager userManager = new UserManager();
IUserManager userProxy = new UserProxy(userManager);
userProxy.addUser("MAC", "XXXXXXX");
1
2
3

首先创建了一个真实类的实例UserManager，然后使用它来创建一个代理对象UserProxy。通过代理对象来调用addUser方法。在执行这个方法时，代理对象会先进行权限校验，然后再调用真实对象的addUser方法来实际添加用户。

---

Android开发中使用动态代理

在Android开发中，动态代理通常使用Java的反射机制来实现。给出下面的代码展示如何利用动态代理。

首先，定义一个接口IUserManager，它将被代理类和真实类实现：

public interface IUserManager {
    void addUser(String name, String password);
}
1
2
3

然后，定义一个真实类UserManager，它实现了IUserManager接口：

public class UserManager implements IUserManager {
    @Override
    public void addUser(String name, String password) {
        // 添加用户的业务逻辑
    }
}
1
2
3
4
5
6

接下来，定义一个PermissionHandler类，它实现了InvocationHandler接口，并包含一个真实类UserManager的实例：

public class PermissionHandler implements InvocationHandler {
    private IUserManager userManager;

    public PermissionHandler(IUserManager userManager) {
        this.userManager = userManager;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用方法之前，进行权限校验
        if (checkPermission()) {
            return method.invoke(userManager, args);
        } else {
            throw new RuntimeException("无权限进行该操作");
        }
    }

    private boolean checkPermission() {
        // 校验用户权限的业务逻辑
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个类中，实现了invoke方法，并在其中进行了权限校验。如果校验通过，则调用真实类UserManager的相应方法，否则抛出一个运行时异常。

最后，在使用时，我们可以这样来创建代理对象并调用其方法：

IUserManager userManager = new UserManager();
PermissionHandler handler = new PermissionHandler(userManager);
IUserManager userProxy = (IUserManager) Proxy.newProxyInstance(userManager.getClass().getClassLoader(),
        new Class[]{IUserManager.class}, handler);
userProxy.addUser("Tom", "123456");
1
2
3
4
5

创建了一个真实类的实例UserManager，然后使用它来创建一个PermissionHandler对象。使用Proxy类的静态方法newProxyInstance来创建代理对象userProxy。在创建代理对象时指定真实类的类加载器和实现的接口，以及PermissionHandler对象作为代理对象的处理器；通过代理对象来调用addUser方法。在执行这个方法时，代理对象会先进行权限校验，然后再调用真实对象的addUser方法来实际添加用户。