ARouter
💪 A framework for assisting in the renovation of Android componentization (帮助 Android App 进行组件化改造的路由框架)
Top Related Projects
🍭灵活的组件化路由框架.
WMRouter是一款Android路由框架,基于组 件化的设计思路,有功能灵活、使用简单的特点。
android java and javascript bridge, inspired by wechat webview jsbridge
A powerful componentized framework.一个强大、100% 兼容、支持 AndroidX、支持 Kotlin并且灵活的组件化框架. 大家尽量用 纯 Kotlin 的 KComponent 呀!!!
A powerful and lightweight plugin framework for Android
Quick Overview
ARouter is a lightweight Android component-based routing framework developed by Alibaba. It simplifies the process of navigating between activities, fragments, and services in large-scale Android applications, providing a centralized and flexible approach to app navigation.
Pros
- Easy integration and minimal setup required
- Supports both compile-time and runtime route registration
- Provides powerful features like interceptors, route guards, and dependency injection
- Excellent performance with minimal impact on app size and runtime
Cons
- Limited documentation in English, which may be challenging for non-Chinese speakers
- Steep learning curve for advanced features
- Requires annotation processing, which can increase build times
- May introduce complexity in smaller projects where simpler navigation methods suffice
Code Examples
- Basic navigation:
// Navigate to an activity
ARouter.getInstance().build("/home/main").navigation()
// Navigate with parameters
ARouter.getInstance().build("/user/profile")
.withString("userId", "12345")
.navigation()
- Using interceptors:
@Interceptor(priority = 8, name = "Login Interceptor")
class LoginInterceptor : IInterceptor {
override fun process(postcard: Postcard, callback: InterceptorCallback) {
if (isLoggedIn()) {
callback.onContinue(postcard)
} else {
callback.onInterrupt(RuntimeException("Please login first"))
}
}
}
- Dependency injection:
@Route(path = "/test/activity")
class TestActivity : AppCompatActivity() {
@Autowired
lateinit var name: String
@Autowired
lateinit var age: Int
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
ARouter.getInstance().inject(this)
}
}
Getting Started
- Add ARouter dependencies to your
build.gradle
:
android {
defaultConfig {
...
javaCompileOptions {
annotationProcessorOptions {
arguments = [AROUTER_MODULE_NAME: project.getName()]
}
}
}
}
dependencies {
implementation 'com.alibaba:arouter-api:1.5.2'
annotationProcessor 'com.alibaba:arouter-compiler:1.5.2'
}
- Initialize ARouter in your Application class:
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
if (BuildConfig.DEBUG) {
ARouter.openLog()
ARouter.openDebug()
}
ARouter.init(this)
}
}
- Add route annotations to your activities:
@Route(path = "/home/main")
class MainActivity : AppCompatActivity() {
// ...
}
Competitor Comparisons
🍭灵活的组件化路由框架.
Pros of Router
- Simpler setup and configuration process
- Lighter weight with fewer dependencies
- More flexible URL matching patterns
Cons of Router
- Less comprehensive documentation
- Fewer advanced features (e.g., no built-in interceptors)
- Smaller community and ecosystem
Code Comparison
ARouter:
@Route(path = "/test/activity")
public class TestActivity extends Activity {
@Autowired
String name;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ARouter.getInstance().inject(this);
}
}
Router:
@Route("test/activity")
public class TestActivity extends Activity {
@InjectParam
String name;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Router.injectParams(this);
}
}
Both libraries use annotations for route definition and parameter injection. ARouter uses @Route
and @Autowired
, while Router uses @Route
and @InjectParam
. The injection process is similar, with ARouter using ARouter.getInstance().inject(this)
and Router using Router.injectParams(this)
.
ARouter generally offers more features and has a larger community, making it suitable for complex projects. Router, on the other hand, is simpler and lighter, which may be preferable for smaller projects or those prioritizing minimal dependencies.
WMRouter是一款Android路由框架,基于组件化的设计思路,有功能灵活、使用简单的特点。
Pros of WMRouter
- More flexible and extensible architecture, allowing for easier customization
- Better support for multi-module projects and component-based development
- Enhanced performance optimization, especially for large-scale applications
Cons of WMRouter
- Steeper learning curve due to more complex API and configuration options
- Less community support and fewer third-party resources compared to ARouter
- Requires more setup and configuration for basic usage
Code Comparison
WMRouter:
@RouterUri(path = "/user/profile")
public class UserProfileActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Activity implementation
}
}
ARouter:
@Route(path = "/user/profile")
public class UserProfileActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Activity implementation
}
}
Both libraries use similar annotation-based routing, but WMRouter's @RouterUri
offers more advanced configuration options compared to ARouter's @Route
annotation. WMRouter also provides more flexibility in defining complex routing rules and handling deep linking scenarios.
android java and javascript bridge, inspired by wechat webview jsbridge
Pros of JsBridge
- Lightweight and focused on JavaScript-to-native communication
- Simple implementation for basic web-to-native interactions
- Easy to integrate into existing projects
Cons of JsBridge
- Limited functionality compared to ARouter's comprehensive routing system
- Lacks advanced features like dependency injection and module isolation
- May require additional setup for complex navigation scenarios
Code Comparison
JsBridge:
webView.registerHandler("submitFromWeb", new BridgeHandler() {
@Override
public void handler(String data, CallBackFunction function) {
function.onCallBack("Response from Java");
}
});
ARouter:
@Route(path = "/test/activity")
public class YourActivity extends Activity {
@Autowired
String key1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ARouter.getInstance().inject(this);
}
}
Summary
JsBridge is a lightweight solution for JavaScript-to-native communication, while ARouter offers a comprehensive routing system for Android applications. JsBridge is simpler to implement for basic web interactions but lacks the advanced features and flexibility of ARouter. The choice between the two depends on the specific requirements of the project, with JsBridge being suitable for simpler web-native interactions and ARouter excelling in complex navigation and modular app architectures.
A powerful componentized framework.一个强大、100% 兼容、支持 AndroidX、支持 Kotlin并且灵活的组件化框架. 大家尽量用 纯 Kotlin 的 KComponent 呀!!!
Pros of Component
- More lightweight and flexible architecture
- Better support for Kotlin and coroutines
- Easier to customize and extend
Cons of Component
- Less mature and less widely adopted
- Fewer features out-of-the-box
- Smaller community and ecosystem
Code Comparison
ARouter:
@Route(path = "/test/activity")
public class TestActivity extends Activity {
@Autowired
String key1;
@Autowired
int key2;
}
Component:
@RouterAnno(hostAndPath = "test/activity")
class TestActivity : Activity() {
@ServiceAutowiredAnno
lateinit var service: TestService
@ParameterAnno("key")
lateinit var value: String
}
Both libraries use annotations for routing and dependency injection, but Component's syntax is more Kotlin-friendly. ARouter uses separate annotations for routing and parameter injection, while Component combines them. Component also provides built-in support for injecting services, which can be useful for modular architectures.
ARouter has a larger user base and more extensive documentation, making it easier to find solutions to common problems. However, Component's lighter weight and better Kotlin support may make it more appealing for newer projects, especially those heavily using Kotlin and coroutines.
A powerful and lightweight plugin framework for Android
Pros of VirtualAPK
- Supports dynamic loading of complete APKs, enabling true plugin architecture
- Allows for on-demand loading of features, reducing initial app size
- Provides more flexibility for large-scale apps with multiple teams
Cons of VirtualAPK
- More complex setup and implementation compared to ARouter
- Potential security concerns with dynamically loaded code
- May require more careful management of versioning and compatibility
Code Comparison
VirtualAPK (loading a plugin):
PluginManager pluginManager = PluginManager.getInstance(context);
pluginManager.loadPlugin(new File(apkPath));
ARouter (navigation):
ARouter.getInstance().build("/test/activity")
.withLong("key1", 666L)
.navigation();
Key Differences
- VirtualAPK focuses on loading entire APKs as plugins, while ARouter is primarily for in-app navigation and module communication
- VirtualAPK offers more extensive runtime flexibility but with increased complexity
- ARouter provides a simpler, annotation-based approach for routing between components within a single app
Both projects aim to improve modularity and scalability in Android apps, but they address different aspects of app architecture. VirtualAPK is better suited for large, complex apps that require dynamic feature loading, while ARouter excels in simplifying navigation and communication between existing app components.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
A framework for assisting in the renovation of Android app componentization
Lastest version
module | arouter-api | arouter-compiler | arouter-register | arouter-idea-plugin |
---|---|---|---|---|
version |
Demo
Demo apkãDemo Gif
I. Feature
- Supports direct parsing of standard URLs for jumps and automatic injection of parameters into target pages
- Support for multi-module
- Support for interceptor
- Support for dependency injection
- InstantRun support
- MultiDex support
- Mappings are grouped by group, multi-level management, on-demand initialization
- Supports users to specify global demotion and local demotion strategies
- Activity, interceptor and service can be automatically registered to the framework
- Support multiple ways to configure transition animation
- Support for fragment
- Full kotlin support (Look at Other#2)
- Generate route doc support
- Provide IDE plugin for quick navigation to target class
- Support Incremental annotation processing
- Support register route meta dynamic.
II. Classic Case
- Forward from external URLs to internal pages, and parsing parameters
- Jump and decoupling between multi-module
- Intercept jump process, handle login, statistics and other logic
- Cross-module communication, decouple components by IoC
III. Configuration
-
Adding dependencies and configurations
android { defaultConfig { ... javaCompileOptions { annotationProcessorOptions { arguments = [AROUTER_MODULE_NAME: project.getName()] } } } } dependencies { // Replace with the latest version compile 'com.alibaba:arouter-api:?' annotationProcessor 'com.alibaba:arouter-compiler:?' ... } // Old version of gradle plugin (< 2.2), You can use apt plugin, look at 'Other#1' // Kotlin configuration reference 'Other#2'
-
Add annotations
// Add annotations on pages that support routing (required) // The path here needs to pay attention to need at least two levels : /xx/xx @Route(path = "/test/activity") public class YourActivity extend Activity { ... }
-
Initialize the SDK
if (isDebug()) { // These two lines must be written before init, otherwise these configurations will be invalid in the init process ARouter.openLog(); // Print log ARouter.openDebug(); // Turn on debugging mode (If you are running in InstantRun mode, you must turn on debug mode! Online version needs to be closed, otherwise there is a security risk) } ARouter.init(mApplication); // As early as possible, it is recommended to initialize in the Application
-
Initiate the routing
// 1. Simple jump within application (Jump via URL in 'Advanced usage') ARouter.getInstance().build("/test/activity").navigation(); // 2. Jump with parameters ARouter.getInstance().build("/test/1") .withLong("key1", 666L) .withString("key3", "888") .withObject("key4", new Test("Jack", "Rose")) .navigation();
-
Add confusing rules (If Proguard is turn on)
-keep public class com.alibaba.android.arouter.routes.**{*;} -keep public class com.alibaba.android.arouter.facade.**{*;} -keep class * implements com.alibaba.android.arouter.facade.template.ISyringe{*;} # If you use the byType method to obtain Service, add the following rules to protect the interface: -keep interface * implements com.alibaba.android.arouter.facade.template.IProvider # If single-type injection is used, that is, no interface is defined to implement IProvider, the following rules need to be added to protect the implementation # -keep class * implements com.alibaba.android.arouter.facade.template.IProvider
-
Using the custom gradle plugin to autoload the routing table
apply plugin: 'com.alibaba.arouter' buildscript { repositories { mavenCentral() } dependencies { // Replace with the latest version classpath "com.alibaba:arouter-register:?" } }
Optional, use the registration plugin provided by the ARouter to automatically load the routing table(power by AutoRegister). By default, the ARouter will scanned the dex files . Performing an auto-registration via the gradle plugin can shorten the initialization time , it should be noted that the plugin must be used with api above 1.3.0!
-
use ide plugin for quick navigation to target class (Optional)
Search for
ARouter Helper
in the Android Studio plugin market, or directly download thearouter-idea-plugin
zip installation package listed in theLatest version
above the documentation, after installation plugin without any settings, U can find an icon at the beginning of the jump code. () click the icon to jump to the target class that identifies the path in the code.
IV. Advanced usage
-
Jump via URL
// Create a new Activity for monitoring Scheme events, and then directly pass url to ARouter public class SchemeFilterActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Uri uri = getIntent().getData(); ARouter.getInstance().build(uri).navigation(); finish(); } }
AndroidManifest.xml
<activity android:name=".activity.SchemeFilterActivity"> <!-- Scheme --> <intent-filter> <data android:host="m.aliyun.com" android:scheme="arouter"/> <action android:name="android.intent.action.VIEW"/> <category android:name="android.intent.category.DEFAULT"/> <category android:name="android.intent.category.BROWSABLE"/> </intent-filter> </activity>
-
Parse the parameters in the URL
// Declare a field for each parameter and annotate it with @Autowired @Route(path = "/test/activity") public class Test1Activity extends Activity { @Autowired public String name; @Autowired int age; @Autowired(name = "girl") // Map different parameters in the URL by name boolean boy; @Autowired TestObj obj; // Support for parsing custom objects, using json pass in URL @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ARouter.getInstance().inject(this); // ARouter will automatically set value of fields Log.d("param", name + age + boy); } } // If you need to pass a custom object, Create a new class(Not the custom object class),implement the SerializationService, And use the @Route annotation annotation, E.g: @Route(path = "/yourservicegroupname/json") public class JsonServiceImpl implements SerializationService { @Override public void init(Context context) { } @Override public <T> T json2Object(String text, Class<T> clazz) { return JSON.parseObject(text, clazz); } @Override public String object2Json(Object instance) { return JSON.toJSONString(instance); } }
-
Declaration Interceptor (Intercept jump process, AOP)
// A more classic application is to handle login events during a jump so that there is no need to repeat the login check on the target page. // Interceptors will be executed between jumps, multiple interceptors will be executed in order of priority @Interceptor(priority = 8, name = "test interceptor") public class TestInterceptor implements IInterceptor { @Override public void process(Postcard postcard, InterceptorCallback callback) { ... // No problem! hand over control to the framework callback.onContinue(postcard); // Interrupt routing process // callback.onInterrupt(new RuntimeException("Something exception")); // The above two types need to call at least one of them, otherwise it will not continue routing } @Override public void init(Context context) { // Interceptor initialization, this method will be called when sdk is initialized, it will only be called once } }
-
Processing jump results
// U can get the result of a single jump ARouter.getInstance().build("/test/1").navigation(this, new NavigationCallback() { @Override public void onFound(Postcard postcard) { ... } @Override public void onLost(Postcard postcard) { ... } });
-
Custom global demotion strategy
// Implement the DegradeService interface @Route(path = "/xxx/xxx") public class DegradeServiceImpl implements DegradeService { @Override public void onLost(Context context, Postcard postcard) { // do something. } @Override public void init(Context context) { } }
-
Decoupled by dependency injection : Service management -- Exposure services
// Declaration interface, other components get the service instance through the interface public interface HelloService extends IProvider { String sayHello(String name); } @Route(path = "/yourservicegroupname/hello", name = "test service") public class HelloServiceImpl implements HelloService { @Override public String sayHello(String name) { return "hello, " + name; } @Override public void init(Context context) { } }
-
Decoupled by dependency injection : Service management -- Discovery service
public class Test { @Autowired HelloService helloService; @Autowired(name = "/yourservicegroupname/hello") HelloService helloService2; HelloService helloService3; HelloService helloService4; public Test() { ARouter.getInstance().inject(this); } public void testService() { // 1. Use Dependency Injection to discover services, annotate fields with annotations helloService.sayHello("Vergil"); helloService2.sayHello("Vergil"); // 2. Discovering services using dependency lookup, the following two methods are byName and byType helloService3 = ARouter.getInstance().navigation(HelloService.class); helloService4 = (HelloService) ARouter.getInstance().build("/yourservicegroupname/hello").navigation(); helloService3.sayHello("Vergil"); helloService4.sayHello("Vergil"); } }
-
Pretreatment Service
@Route(path = "/xxx/xxx") public class PretreatmentServiceImpl implements PretreatmentService { @Override public boolean onPretreatment(Context context, Postcard postcard) { // Do something before the navigation, if you need to handle the navigation yourself, the method returns false } @Override public void init(Context context) { } }
-
Dynamic register route meta Applicable to apps with plug-in architectures or some scenarios where routing information needs to be dynamically registeredï¼Dynamic registration can be achieved through the interface provided by ARouter, The target page and service need not be marked with @Route annotationï¼Only the routing information of the same group can be registered in the same batch
ARouter.getInstance().addRouteGroup(new IRouteGroup() { @Override public void loadInto(Map<String, RouteMeta> atlas) { atlas.put("/dynamic/activity", // path RouteMeta.build( RouteType.ACTIVITY, // Route type TestDynamicActivity.class, // Target class "/dynamic/activity", // Path "dynamic", // Group 0, // not need 0 // Extra tag, Used to mark page feature ) ); } });
V. More features
-
Other settings in initialization
ARouter.openLog(); // Open log ARouter.openDebug(); // When using InstantRun, you need to open this switch and turn it off after going online. Otherwise, there is a security risk. ARouter.printStackTrace(); // Print thread stack when printing logs
-
API description
// Build a standard route request ARouter.getInstance().build("/home/main").navigation(); // Build a standard route request, via URI Uri uri; ARouter.getInstance().build(uri).navigation(); // Build a standard route request, startActivityForResult // The first parameter must be Activity and the second parameter is RequestCode ARouter.getInstance().build("/home/main", "ap").navigation(this, 5); // Pass Bundle directly Bundle params = new Bundle(); ARouter.getInstance() .build("/home/main") .with(params) .navigation(); // Set Flag ARouter.getInstance() .build("/home/main") .withFlags(); .navigation(); // For fragment Fragment fragment = (Fragment) ARouter.getInstance().build("/test/fragment").navigation(); // transfer the object ARouter.getInstance() .withObject("key", new TestObj("Jack", "Rose")) .navigation(); // Think the interface is not enough, you can directly set parameter into Bundle ARouter.getInstance() .build("/home/main") .getExtra(); // Transition animation (regular mode) ARouter.getInstance() .build("/test/activity2") .withTransition(R.anim.slide_in_bottom, R.anim.slide_out_bottom) .navigation(this); // Transition animation (API16+) ActivityOptionsCompat compat = ActivityOptionsCompat. makeScaleUpAnimation(v, v.getWidth() / 2, v.getHeight() / 2, 0, 0); // ps. makeSceneTransitionAnimation, When using shared elements, you need to pass in the current Activity in the navigation method ARouter.getInstance() .build("/test/activity2") .withOptionsCompat(compat) .navigation(); // Use green channel (skip all interceptors) ARouter.getInstance().build("/home/main").greenChannel().navigation(); // Use your own log tool to print logs ARouter.setLogger(); // Use your custom thread pool ARouter.setExecutor();
-
Get the original URI
String uriStr = getIntent().getStringExtra(ARouter.RAW_URI);
-
Rewrite URL
// Implement the PathReplaceService interface @Route(path = "/xxx/xxx") public class PathReplaceServiceImpl implements PathReplaceService { /** * For normal path. * * @param path raw path */ String forString(String path) { // Custom logic return path; } /** * For uri type. * * @param uri raw uri */ Uri forUri(Uri uri) { // Custom logic return url; } }
-
Generate router doc
// Edit build.gradle, add option 'AROUTER_GENERATE_DOC = enable' // Doc file : build/generated/source/apt/(debug or release)/com/alibaba/android/arouter/docs/arouter-map-of-${moduleName}.json android { defaultConfig { ... javaCompileOptions { annotationProcessorOptions { arguments = [AROUTER_MODULE_NAME: project.getName(), AROUTER_GENERATE_DOC: "enable"] } } } }
VI. Other
-
Old version of gradle plugin configuration
apply plugin: 'com.neenbedankt.android-apt' buildscript { repositories { mavenCentral() } dependencies { classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4' } } apt { arguments { AROUTER_MODULE_NAME project.getName(); } } dependencies { compile 'com.alibaba:arouter-api:x.x.x' apt 'com.alibaba:arouter-compiler:x.x.x' ... }
-
Kotlin project configuration
// You can refer to the wording in the "module-kotlin" module apply plugin: 'kotlin-kapt' kapt { arguments { arg("AROUTER_MODULE_NAME", project.getName()) } } dependencies { compile 'com.alibaba:arouter-api:x.x.x' kapt 'com.alibaba:arouter-compiler:x.x.x' ... }
VII. Communication
-
Communication
-
DingDing group1
-
QQ group1
-
QQ group2
-
Top Related Projects
🍭灵活的组件化路由框架.
WMRouter是一款Android路由框架,基于组件化的设计思路,有功能灵活、使用简单的特点。
android java and javascript bridge, inspired by wechat webview jsbridge
A powerful componentized framework.一个强大、100% 兼容、支持 AndroidX、支持 Kotlin并且灵活的组件化框架. 大家尽量用 纯 Kotlin 的 KComponent 呀!!!
A powerful and lightweight plugin framework for Android
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot