首先解释为什么需要模块开发。在大型的Android项目中有很多组是单独开发自己的模块的。比如有商业化组，UGC组等等。但是有时候可能我想从商业化的A中去调用或者跳转到UGC的B中。这时候为了不破坏整体项目结构，就需要本文所提的这个东西。情况如下图所示，就好像网络中的路由表一样。所以最终目的就是维护一个路由表来使得各个Module之间相互联系。
屏幕快照 2017-06-03 下午8.45.01.png
屏幕快照 2017-06-03 下午8.45.10.png
首先看看我们最后实现路由后的使用发方式：首先在Application中注册路由
然后在各自的地方使用。
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
setupRouter();
}
private void setupRouter() {
Router.addRouter(ActivityRule.ACTIVIVY_SCHEME + "a_activity", AActivity.class);
Router.addRouter(ActivityRule.ACTIVIVY_SCHEME + "b_activity", BActivity.class);
}
}
使用事例
public class AActivity extends AppCompatActivity {
Button button;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.aactivity_layout);
button = (Button) findViewById(R.id.go_to_B);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = Router.invoke(AActivity.this, ActivityRule.ACTIVIVY_SCHEME+"b_activity");
startActivity(intent);
}
});
}
}
首先创建一个Rule接口
public interface Rule<T, V> {
/**
* 添加具体的路由
* @param pattern
* @param klass
*/
void router(String pattern, Class<T> klass);
/**
* 添加实现 例如Intent
* @param pattern
*/
V invoke(Context ctx, String pattern);
}
创建具体的实现类
public abstract class BaseRule<T> implements Rule<T, Intent> {
//Intent路由表
private HashMap<String, Class<T>> mRules = new HashMap<>();
@Override
public void router(String pattern, Class<T> klass) {
mRules.put(pattern, klass);
}
/**
* 构造一个Intent
* @param ctx
* @param pattern
* @return
*/
@Override
public Intent invoke(Context ctx, String pattern) {
Class<T> klass = mRules.get(pattern);
if (klass == null) {
throwsException(pattern);
}
return new Intent(ctx, klass);
}
public abstract void throwsException(String pattern);
}
创建一个具体的Rule类比如ActivityRule类
public class ActivityRule<Activity> extends BaseRule<Activity> {
public static final String ACTIVIVY_SCHEME = "activity_route";
@Override
public void throwsException(String pattern) {
throw new ActivityNotFoundException(pattern);
}
}
在创建好各个Rule对象后，我们在创建一个Router的代理类RouterInternal
package com.example.mylibrary.router;
import android.content.Context;
import java.util.HashMap;
import java.util.Set;
/**
* Created by fupeidong on 2017/6/3.
*/
public class RouterInternal {
private static RouterInternal sInstance;
/** scheme->路由规则 */
private HashMap<String, Rule> mRules;
private RouterInternal() {
mRules = new HashMap<>();
initDefaultRouter();
}
/**
* 可以扩展比如Service和Broadcast等
*/
private void initDefaultRouter() {
addRule(ActivityRule.ACTIVIVY_SCHEME, new ActivityRule());
}
static RouterInternal get() {
if (sInstance == null) {
synchronized (RouterInternal.class) {
if (sInstance == null) {
sInstance = new RouterInternal();
}
}
}
return sInstance;
}
public final RouterInternal addRule(String scheme, Rule rule) {
mRules.put(scheme, rule);
return this;
}
private <T,V> Rule<T,V> getRule(String pattern) {
HashMap<String, Rule> rules = mRules;
Set<String> keySet = rules.keySet();
Rule<T,V> rule = null;
for (String scheme: keySet) {
if (pattern.startsWith(scheme)) {
rule = rules.get(scheme);
break;
}
}
return rule;
}
public final <T> RouterInternal addRouter(String pattern, Class<T> klass) {
Rule<T, ?> rule = getRule(pattern);
if (rule == null) {
throw new NotRouteException("unknown" + pattern);
}
rule.router(pattern, klass);
return this;
}
final <V> V invoke(Context ctx, String pattern) {
Rule<?, V> rule = getRule(pattern);
if (rule == null) {
throw new NotRouteException("unknown"+pattern);
}
return rule.invoke(ctx, pattern);
}
}
最后我们创建我们的使用类Router
public class Router {
public static RouterInternal addRule(String scheme, Rule rule) {
RouterInternal routerInternal = RouterInternal.get();
routerInternal.addRule(scheme, rule);
return routerInternal;
}
public static <T> RouterInternal addRouter(String pattern, Class<T> klass) {
return RouterInternal.get().addRouter(pattern, klass);
}
public static <V> V invoke(Context ctx, String pattern) {
return RouterInternal.get().invoke(ctx, pattern);
}
}
