Thomas braun dependency-injection_with_robo_guice-presentation-final
1 like991 views
The document discusses dependency injection (DI) using RoboGuice in Android applications. DI makes code more concise, modular, and easier to test by allowing classes to declare dependencies without knowing how they are satisfied. RoboGuice uses annotations to inject dependencies into activities and services. It allows for loose coupling, high cohesion, and centralized configuration through bindings. DI improves testability by increasing controllability, observability, and isolation of units under test.
Thomas braun dependency-injection_with_robo_guice-presentation-final
- 1. Dependency Injection with RoboGuice ©2013 Tom Braun <tom.braun@apps4use.com>
- 3. {concept} Inversion of Control (IoC) {concept} Dependency Injection (DI) Googe Guice Spring core PicoContainer Plexus Android RoboGuice Dagger Annotations
- 4. Dependency Injection (DI) Makes code ... ● more concise ● more modular ● easier to test
- 5. public class GuicelessActivity extends Activity { … @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); @ContentView(R.layout.main) public class GuicyActivity extends RoboActivity {
- 6. ... TextView outputText; ... outputText =(TextView)findViewById(R.id.text_output); @InjectView(R.id.text_output) TextView outputText;
- 7. String appName; ... appName = getString(R.string.app_name); @InjectView(R.id.text_output) TextView outputText;
- 8. SensorManager sensorManager; ... sensorManager = (SensorManager)getSystemService(SENSOR_SERVICE); @Inject SensorManager sensorManager;
- 9. SomeController someController; .. someController = new SomeController(this); @Inject SomeController someController; public class SomeController { Activity hostActivity; @Inject public SomeController(Activity hostActivity) { this.hostActivity = hostActivity; } }
- 10. public class GuicelessActivity extends Activity { TextView outputText; String appName; SensorManager sensorManager; SomeController someController; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); outputText = (TextView)findViewById(R.id.text_output); appName = getString(R.string.app_name); sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); someController = new SomeController(this); } } @ContentView(R.layout.main) public class GuicyActivity extends RoboActivity { @InjectView(R.id.text_output) TextView outputText; @InjectResource(R.string.app_name) String appName; @Inject SensorManager sensorManager; @Inject SomeController someController; }
- 11. 15 LOC → 7 LOC = more concisene
- 12. Dependency Injection (DI) Makes code ... ● more concise ● more modular ● easier to test
- 13. Bindings public class MyModule extends AbstractModule { @Override protected void configure() { // custom binding go here } }
- 15. bind(ISomeService.class) .toInstance(new SomeServiceReal("yes", 1));
- 16. @Inject @Provides public AnotherService provideAnotherService( ISomeService someService ) { return new AnotherService(someService, "bla"); }
- 17. Bindings allows for ● wiring up components ● configuring components
- 18. Adding Google Analytics to an Activity ● onCreate → startNewSession ● onResume → trackPageView ● onDestroy → stopSession ● Attributes ● Support code
- 19. Component Bloat-Up ● anti pattern: God Class ● low coherence ● tight coupling ● low separation of concernes
- 20. public void onCreate(@Observes OnCreateEvent onCreateEvent)
- 21. @Inject protected AnalyticsMixin analyticsMixin;
- 22. We get: ● loose coupling ● high coherence ● centralized wiring ● centralized configuration
- 23. Testability (see wikipedia) ● controllability: The degree to which it is possible to control the state of the component under test (CUT) as required for testing. ● observability: The degree to which it is possible to observe (intermediate and final) test results. ● isolateability: The degree to which the CUT can be tested in isolation. ● separation of concerns: The degree to which the CUT has a single, well defined responsibility. ● understandability: The degree to which the CUT is documented or self-explaining. ● automatability: The degree to which it is possible to automate testing of the CUT. ● heterogeneity: The degree to which the use of diverse technologies requires to use diverse test methods and tools in parallel.
- 24. @RunWith(RobolectricTestRunner.class) public class SomeServiceTest { @Mock private SomeDAO mockDao; @Mock private Logger mockLogger; private SomeService cut; @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); cut.someDao = mockDao; cut.log = mockLogger; } @Test public void testExecute_willPassWhenNotInBeta() { when(mockDao.countSomeStuff()).thenReturn(23); assertTrue(cut.hasEnoughStuff()); verify(mockLogger, times(1)).info("have 23"); } }
- 25. Testability (see wikipedia) ● controllability ++ ● observability ++ ● isolateability ++ ● separation of concerns ++ ● understandability + ● automatability + ● heterogeneity o
- 26. Dependency Injection (DI) Makes code ... ● more concise ● more modular ● easier to test
- 27. References: ● DI: http://martinfowler.com/articles/injection.html ● Guice: http://code.google.com/p/google-guice/ ● RoboGuice: https://github.com/roboguice/roboguice ● Testability: http://en.wikipedia.org/wiki/Software_testability ● Mockito: http://code.google.com/p/mockito/ ● Rebolectric: http://pivotal.github.io/robolectric/ Contact: ● tom.braun@apps4use.com ● @tom___b ● http://play.google.com → GrooveGrid