android中利用代理模式简单实现界面之间的跳转与传值

前言

在开始这个实践之前，我们应该首先明白以下几个问题:

1.什么是代理模式?

2.为什么要使用它?

3.怎么使用它?

4.它的原理是什么?

什么是代理模式?

代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

所谓代理，就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式类图如下：



在代理模式中的概念：

　　●　　抽象接口：代理类和委托类的共同接口,提供业务逻辑的声明。

　　●　　代理类：代理类负责转发消息给委托类、并对委托类的访问进行控制

　　●　　委托类：又被称为被代理类,负责具体业务逻辑的实现。

为什么要使用它?

使用代理模式创建代理对象，让代理对象控制目标对象的访问(目标对象可以是远程的对象、创建开销大的对象或需要安全控制的对象),并且可以在不改变目标对象的情况下添加一些额外的功能。

怎么使用它?

根据程序运行时，代理类是否存在将代理分为静态代理和动态代理。

静态代理的使用如下:

抽象接口,负责具体业务声明

public interface IFactory {
void SellProduct();
}

委托类,负责具体业务的实现

public class FoodFactory implements IFactory{

@Override
public void SellProduct() {

System.out.print("sell food product");
}
}

代理类,负责控制委托类对象的访问

public class ProxyFactory implements IFactory {

private IFactory factory;

public ProxyFactory(IFactory factory) {
this.factory = factory;
}

@Override
public void SellProduct() {
//这里可以增加一些条件的判断,来控制对委托对象的访问
factory.SellProduct();
}
}

Junit单元测试

@Test
public void testStaticProxy() {
//静态代理测试
IFactory factory = new FoodFactory();
ProxyFactory proxyFactory = new                   ProxyFactory(factory);
proxyFactory.SellProduct();
}

分析:由上述代码可以看出，委托类FoodFactory只关注业务本身，代理类ProxyFactory的使用隐藏了业务具体实现，使得业务的重用性更高；然而在现实开发过程中，这种实现是非常少见的，一般情况，业务类会是多个接口的实现，而代理的过程中也需要实现这些接口，且根据不同业务封装，可能就会产生多个代理类而这时又因为功能需求，不得不访问这些接口的时候，这种代理方式就显得捉襟见肘了；这些情况下，就需要引用动态代理来解决了.

动态代理

在这里就利用动态代理来实现界面之间的跳转与传值,希望可以帮助大家更好的更透彻的理解动态代理的使用场景.

为了实现动态代理，要引入相关的类和接口 java.lang.reflect.Proxy 提供了一系列的static方法，用来创建代理类或对象，这个类是所有动态代理类的父类以及java.lang.reflect.InvocationHandler(调用处理器接口，只有一个invoke方法，处理动态代理类对象方法的调用，每个动态代理类都会关联一个InvocationHandler).

下面是对方法的介绍

public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,InvocationHandler h)

-ClassLoader loader // 被代理类的类加载器，用来创建代理类

- Class<？>[] interfaces //被代理类实现的接口，创建的代理类会实现这些接口

- InvocationHandler invocationHandler //最关键的接口！它只有一个 invoke 方法，是代理类进行 拦截操作 的入口，一般需要自定义一个 Handler 来实现方法增强。

public Object invoke(Object proxy, Method method, Object[] args)

proxy 就是上面通过Proxy.newProxyInstance生成的对象proxy

method 是proxy的调用的任何方法

args 是method的参数

接下来我们实现动态代理

(1)编写抽象接口,声明activity之间的跳转

public interface Jumper {

@ActivityInfo(clz = NoParametersActivity.class)
IntentHandler gotoNoParametersActivity();

@ActivityInfo(clz = ParametersActivity.class)
IntentHandler gotoParametersActivity(@Extra(value = "param",author = "authorName")String userName);
}

(2)生成动态代理对象jumper





最重要的业务拦截处理在InvocationHandler中处理



(3)调用方法实现页面跳转并传参

jumper.gotoParametersActivity("15010").startActivity(this);

(4)在跳转页面获取值



只需要上面四步就可实现跳转,稍后我会奉上源码.

动态代理的实现原理

不说话, 直接附上源码，更好的理解动态代理机制

下面这段代码引入了(http://paddy-w.iteye.com/blog/841798)博客中的片段。
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });

m0 = Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);

m3 = Class.forName("***.RealSubject").getMethod("request",
new Class[0]);

m2 = Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);

} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
} //static

public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}

@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}

@Override
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}

public final void request() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}

@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}

这个类的生成最终是在Proxy中是在通过native方法Proxy.generateProxy生成类的字节码，再经过ClassLoader加载，就像class文件就被加载的过程，然后用newInstance方式生成最终的Proxy对象，具体的细节可以自行查看源码.

上面的$Proxy0就是生成的动态代理类,看到上面就明白代理类对方法的调用是怎么与InvocationHandler中invoke()方法关联的了,至此分析结束.

android中使用动态代理实现界面跳转传值demo下载地址：