"Build command-based architecture in reactive manner" from Alexander Kozlov

Main topic is how to build flexible, scalable and resilient architecture based on command-like actions, RxJava-powered pipes and services. Also we gonna discuss and show how one can effectively split service layer from business logic.

Transcript

1. Janet Build command-based architecture in reactive manner Alexander Kozlov Android software engineer
2. What’s our application made of?
3. What’s our application made of? User Interface
4. What’s our application made of? User Interface UI Presentation
5. What’s our application made of? User Interface UI Presentation Service Presentation
6. What’s our application made of? User Interface UI Presentation Service Presentation Entities Service
7. Usual Service Layer • Communication with server side • Processing business layer • Working with entities (storage) • Security rules • Other use cases
8. Usual Service Layer • Communication with server side • Processing business layer • Working with entities (storage) • Security rules • Other use cases ➡ NetworkManager ➡ UserManager, ChatManager ➡ StorageManager ➡ SecurityManager ➡ (*)Manager
9. Usual Service Layer • Communication with server side • Processing business layer • Working with entities (storage) • Security rules • Other use cases ➡ NetworkManager ➡ UserManager, ChatManager ➡ StorageManager ➡ SecurityManager ➡ (*)Manager Use Cases, Repositories, Adapters Interactors +
10. Usual Service Layer • Communication with server side • Processing business layer • Working with entities (storage) • Security rules • Other use cases } Actions
11. When we think about actions NetworkManager UserManager StorageManager LoginAction RegisterAction UsersAction AddFriendAction DeleteFriendAction StoreFriendsAction
12. Encapsulation Reusability Scalability Inheritance What we think about actions Declarative Mockable Testable
13. Problem of different approaches • async-http • Goro • EventBus • DBFlow • Retrofit 2 • Goro • RxJava • Realm • Retrofit • RoboSpice • RxJava • SnappyDB
14. Problem of different approaches • Action-based Framework • Action-based Framework • Action-based Framework
15. Based on actions Flexibility and scalability. 
 Scale functionality using services Reactive approach for actions
 interaction by RXJava Throw-safety architecture We made Janet
16. Janet Structure Janet ActionPipe Service Presentation ActionPipe ActionPipe Service
17. Janet Flow Action
18. Janet Flow Action Send ActionPipe
19. Janet Flow Action Send ActionPipe Janet
20. Janet Flow Action Send ActionPipe Janet Service
21. Janet Flow Action Send ActionPipe Janet Service Result
22. Janet Flow Action Send ActionPipe Janet Service Result Result
23. Janet Flow Result Action Send ActionPipe Subscribe Janet Service Result Result PROGRESS SUCCESS FAIL START
24. Janet Flow Result Action Send ActionPipe Subscribe Janet Service Result Result PROGRESS SUCCESS FAIL START Result = Action + Status
25. Janet Flow ActionState Action Send ActionPipe Subscribe Janet Services ActionState ActionState PROGRESS SUCCESS FAIL START ActionState = Action + Status
26. Services Janet janet = new Janet.Builder()
 .addService(new HttpActionService(API_URL, httpClient, converter)) 
 .addService(new SqlActionService(...))
 .addService(new XyzActionService(...))
 .build();
27. Services To add new ActionService you should override 3 methods • getSupportedAnnotationType - defines what actions are processed by their class annotation; • sendInternal – is called upon new action is sent to pipe; • cancel – is called upon action is canceled from pipe;
28. Possible Services LocationActionService PersistActionService SSHActionService BitmapActionService FTPActionService TrackingActionService SyncActionService GITActionService RESTActionService VideoActionService SQLActionService
29. Janet Services • HttpActionService to provide HTTP/HTTPS requests execution • AsyncActionService to provide support for async protocols, e.g. socket.io • CommandActionService to delegate job back to command action
30. Janet Action @HttpAction(value = “/demo/{id}”, method = GET) 
 public class SampleHttpAction {
 @Query("param") String param; @Path("id") String id;
 @Response SampleData responseData;
 } Processed by HttpActionService
 See github.com/techery/janet-http
31. How to use? // Create pipe for action class with janet ActionPipe<SampleHttpAction> actionPipe = janet.createPipe(SampleHttpAction.class);
32. How to use? // Create pipe for action class with janet ActionPipe<SampleHttpAction> actionPipe = janet.createPipe(SampleHttpAction.class); // Register request result observer
 actionPipe.observe() .subscribe(new ActionStateSubscriber<SampleHttpAction>()
 .onStart(action -> {})
 .onProgress((action, progress) -> {})
 .onSuccess(action -> {})
 .onFail((action, throwable) -> {})
 );
33. How to use? // Create pipe for action class with janet ActionPipe<SampleHttpAction> actionPipe = janet.createPipe(SampleHttpAction.class); // Register request result observer
 actionPipe.observe() .subscribe(new ActionStateSubscriber<SampleHttpAction>()
 .onStart(action -> {})
 .onProgress((action, progress) -> {})
 .onSuccess(action -> {})
 .onFail((action, throwable) -> {})
 ); // Send action actionPipe.send(new SampleHttpAction()); // or actionPipe.createObservable(new SampleHttpAction()).subscribe();
34. How to use? // Create pipe for action class with janet ActionPipe<SampleHttpAction> actionPipe = janet.createPipe(SampleHttpAction.class); // Register request result observer
 actionPipe.observeWithReplay() .subscribe(new ActionStateSubscriber<SampleHttpAction>()
 .onStart(action -> {})
 .onProgress((action, progress) -> {})
 .onSuccess(action -> {})
 .onFail((action, throwable) -> {})
 ); // Send action actionPipe.send(new SampleHttpAction()); // or actionPipe.createObservable(new SampleHttpAction()).subscribe();
35. How to use? // Create pipe for action class with janet ActionPipe<SampleHttpAction> actionPipe = janet.createPipe(SampleHttpAction.class); // Register request result observer
 actionPipe.observeSuccessWithReplay() .subscribe((action) -> doSomething(action)); // Send action actionPipe.send(new SampleHttpAction()); // or actionPipe.createObservable(new SampleHttpAction()).subscribe();
36. How to use? @Override
 protected void onResume() {
 super.onResume();
 usersPipe.observeWithReplay()
 .compose(bindToLifecycle())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(new ActionStateSubscriber<UsersAction>()
 .onStart((action) -> showProgressLoading(true))
 .onSuccess(action -> {
 updateData(action.getResponse());
 showProgressLoading(false);
 })
 .onFail((action, throwable) -> showProgressLoading(false)));
 }
 
 @OnClick(R.id.button)
 public void loadUsers(){
 usersPipe.send(new UsersAction());
 }
37. How to test? @Before
 public void setup() throws JanetException {
 MockHttpActionService httpActionService = new MockHttpActionService.Builder()
 .bind(new MockHttpActionService.Response(200)
 .body(testUser), request -> request.getUrl().endsWith("user"))
 .build();
 Janet janet = new Janet.Builder().addService(httpActionService).build();
 apiInteractor = new ApiInteractor(janet);
 }
 
 @Test
 public void loadUsers() {
 TestSubscriber<ActionState<UserAction>> subscriber = new TestSubscriber<>();
 apiInteractor.userActionPipe()
 .observe()
 .subscribe(subscriber);
 apiInteractor.userActionPipe().send(new UserAction());
 assertActionSuccess(subscriber, action -> action.getUser().equals(testUser));
 }

38. ActionServiceWrapper Abilities: • Pre/post processing • Additional business logic • Intercepting, re-routing Decorator for ActionService is used to listen for action status or add additional intercepting logic. Possible solutions: caching middleware, Dagger injector, retry policy, etc.
39. ActionServiceWrapper public class AuthServiceWrapper extends ActionServiceWrapper {
 
 private final Storage storage;
 
 public AuthServiceWrapper(HttpActionService actionService, PreferenceWrapper prefs) {
 super(actionService);
 this.storage = prefs;
 }
 
 @Override protected <A> boolean onInterceptSend(ActionHolder<A> holder) {
 if (holder.action() instanceof BaseHttpAction) {
 String authToken = storage.getToken();
 if (!TextUtils.isEmpty(authToken)) {
 ((BaseHttpAction) holder.action()).setToken(authToken);
 }
 }
 return false;
 }

40. Command • Custom operations • Business use cases • Janet action chains Processed by CommandActionService See https://github.com/techery/janet-command
41. Command @CommandAction
 public class SaveBitmapCommand extends Command<File> {
 
 private final Bitmap bitmap;
 
 public SaveBitmapCommand(Bitmap bitmap) {
 this.bitmap = bitmap;
 }
 
 @Override
 protected void run(CommandCallback<File> callback) throws Throwable {
 File file = new File(........);
 FileOutputStream stream = new FileOutputStream(file);
 try {
 boolean saved = bitmap.compress(Bitmap.CompressFormat.JPEG, 90, stream);
 if (saved) {
 callback.onSuccess(file);
 } else {
 callback.onFail(new IllegalStateException("Compressing error"));
 }
 } finally {
 stream.close();
 }
 }
42. Command ActionPipe<SaveBitmapCommand> actionPipe = janet.createPipe(SaveBitmapCommand.class); actionPipe.createObservable(new SaveBitmapCommand(bitmap))
 .subscribe(new ActionStateSubscriber<SaveBitmapCommand>()
 .onSuccess(command -> {
 File file = command.getResult();
 doSometing(file);
 })
 .onFail((command, throwable) -> showError(throwable)));
43. Command @CommandAction
 public class UploadBitmapCommand extends Command<UploadResult> {
 
 @Inject
 Janet janet; private final Bitmap bitmap;
 
 public UploadBitmapCommand(Bitmap bitmap) {
 this.bitmap = bitmap;
 }
 
 @Override
 protected void run(CommandCallback<UploadResult> callback) throws Throwable { janet.createPipe(SaveBitmapCommand.class)
 .createObservableResult(new SaveBitmapCommand(bitmap))
 .map(SaveBitmapCommand::getResult) .flatMap((file) -> janet.createPipe(UploadHttpAction.class) .createObservableResult(new UploadHttpAction(file)) .map(UploadHttpAction::getResponse) )
 .subscribe(callback::onSuccess, callback::onFail);
 }
 }
44. Janet Service Layer Interactors ActionPipe ActionPipe ActionPipe Services Wrappers Presentation UI
45. Janet https://github.com/techery/janet Contributions are welcome Version: Used in 4 project in 3 different componies Tested on production
46. Janet Samples: • Simple Android app: https://github.com/techery/janet-http-android-sample • Advanced Android app: https://github.com/techery/janet-architecture-sample • Flux-like Android app: https://github.com/techery/janet-flux-todo
47. We are hiring! techery.io/jobs