通常博主开发项目时喜欢以Activity 、Service 等组件作为顶级层入口，辅以各类接口作为业务服务。Activity 主要负责维护界面相关的东西，及提供功能所须要的上下文环境，引入功能实现须要的接口。

这些接口的实例通过Roboguice进行注入。（当然你也能够全然不使用Roboguice,但还是建议保留接口注入的设计）。

关于Roboguice

项目地址：https://github.com/roboguice/roboguice .利用Roboguice能够较轻松的注入各种服务。它默认提供了各种android相关的注入如： injectView  ,injectResource 等。

遗憾的是这里将不正确Roboguice的使用具体解说。想了解 Roboguice 的读者能够查看官网的Wiki 或參考：http://www.imobilebbs.com/wordpress/archives/2480

下载须要的包

项目创建

基本功能 

项目仅包括一个Activity，界面上包括一个TextView和Button.点击Button 可查看当前时间。

通常我喜欢把数据相关的模块（db、sharepreferene、net、cache等）归类到Repository中，对上层而言就形成一个数据来源接口。

注意：没有哪一种设计是万能。须要依据最实际的情况，不断的进行权衡，终于选择较合适的系统设计，而且要做好睡着系统的成长须要变更设计的准备。

比如有的android程序比較简单。就全然不须要 IService 服务层。

项目包结构

使用静态类的实现方式

  1 public class AndroidTimeRead {

 2 
 3          public  static TimeViewModel showTime() {
 4               TimeViewModel model =  new TimeViewModel();
 5               model.setTime(String. valueOf(System.currentTimeMillis ()));
 6                 return model;
 7        }
 8 
 9 }
10 
11  public  class MainActivity  extends Activity {
12 
13          private TextView txtShowTime ;
14          private Button btnShow ;
15 
16         @Override
17          protected  void onCreate(Bundle savedInstanceState) {
18                 super.onCreate(savedInstanceState);
19               setContentView(R.layout. activity_main);
20 
21                txtShowTime = (TextView) findViewById(R.id.txtShowTime);
22                btnShow = (Button) findViewById(R.id. btnShow);
23                btnShow.setOnClickListener(  new View.OnClickListener() {
24 
25                       @Override
26                        public  void onClick(View v) {
27                            TimeViewModel viewModel = AndroidTimeRead. showTime();
28                             txtShowTime.setText(viewModel.getTime());
29                      }
30               });
31 
32        }
33 
34 }

还有一个问题是：当你想对MainActivity 进行单元測试，你会发现很困难。AndroidTimeRead 必须被包括进来，假设它还引用了其它的组件（如Db 或 net），那么这些组件也必须包括入内。 静态类型由于一直在内存中，假设它引用了其它类型，则被引用的对象CG无法回收。

改进

 1  public  class AndroidTimeRead {
 2 
 3          private  static  class InstaceHolder{
 4                 public  static AndroidTimeRead instance=  new AndroidTimeRead();
 5        }
 6        
 7          public  static AndroidTimeRead getInstance(){
 8                 return InstaceHolder.instance;
 9        }
10        
11          private AndroidTimeRead(){}
12        
13          public TimeViewModel showTime() {
14               TimeViewModel model =  new TimeViewModel();
15               model.setTime(String. valueOf(System.currentTimeMillis ()));
16                 return model;
17        }
18 
19 }

1        TimeViewModel viewModel = AndroidTimeRead. getInstance().showTime();调用改动

这里去掉了静态的方式，但是却没有解除直接依赖实现的问题。

关注行为

3 }      

  1 private ITimeService timeService ;

 2          // 提供注入点
 3           public  void setTimeService(ITimeService timeService) {
 4                 this.timeService = timeService;
 5        }
 6        
 7         @Override
 8          protected  void onCreate(Bundle savedInstanceState) {
 9                 super.onCreate(savedInstanceState);
10               setContentView(R.layout. activity_main);
11 
12                txtShowTime = (TextView) findViewById(R.id.txtShowTime);
13                btnShow = (Button) findViewById(R.id. btnShow);
14                btnShow.setOnClickListener(  new View.OnClickListener() {
15 
16                       @Override
17                        public  void onClick(View v) {
18                            TimeViewModel viewModel = timeService.showTime();
19                             txtShowTime.setText(viewModel.getTime());
20                      }
21               });
22 
23        }

遗憾的是上面的程序不能正常执行。ITimeService 没有实例化。我们尽管提供了注入点。可是Activity 的生命周期由系统接管。我们无法直接使用。

其实当你使用Roboguice 时也是须要继承自其提供的RoboActivity。

完毕业务代码

在引入Roboguice 前先完毕Demo的结构。

加入ITimeRepository 和相应的实现。并让AndroidTimeRead  依赖 ITimeRepository。
 

1  public  class TimeModel {
2      public  long CurrentTime ;
3 }
4  public  interface ITimeRepository {
5        TimeModel query();
6 }

public  class TimeRepository  implements ITimeRepository {

        @Override
         public TimeModel query() {
               TimeModel model= new TimeModel();
               model.CurrentTime=System. currentTimeMillis();
              
              
                return model;
       }

}

public  class AndroidTimeRead  implements ITimeService {

         private ITimeRepository rep ;

         public AndroidTimeRead(ITimeRepository rep) {
                this.rep = rep;
       }

         public TimeViewModel showTime() {
              TimeViewModel model =  new TimeViewModel();
              model.setTime( "如今的时间是" + String.valueOf( rep.query()));
                return model;
       }

}

能够发现。这里AndroidTimeRead 也是依赖于 ITimeRepository接口的。而且通过构造函数。提供了注入口。

新的时间获取方式的改动，并没有要求MainActivity 函数做不论什么改动。假设是直接使用AndroidTimeRead，则须要变更MainActivity。

引入Roboguice  应该放在哪里？

命名一个Infrastructure包。将须要的基础设施放置在此。

引入RoboActivity

 1  public  class MainActivity  extends RoboActivity {
 2 
 3         @InjectView(R.id.txtShowTime )
 4          private TextView txtShowTime ;
 5         @InjectView(R.id.btnShow )
 6          private Button btnShow ;
 7 
 8         @Inject
 9          private ITimeService timeService ;
10          // 提供注入点
11           public  void setTimeService(ITimeService timeService) {
12                 this.timeService = timeService;
13        }
14        
15         @Override
16          protected  void onCreate(Bundle savedInstanceState) {
17                 super.onCreate(savedInstanceState);
18               setContentView(R.layout. activity_main);
19 
20                btnShow.setOnClickListener(  new View.OnClickListener() {
21 
22                       @Override
23                        public  void onClick(View v) {
24                            TimeViewModel viewModel = timeService.showTime();
25                             txtShowTime.setText(viewModel.getTime());
26                      }
27               });
28 
29        }

1  public  class RoboApplication  extends Application {
2 
3         @Override
4          public  void onCreate() {
5                 super.onCreate();
6               RoboGuice. setBaseApplicationInjector( this, RoboGuice. DEFAULT_STAGE,
7                            RoboGuice. newDefaultRoboModule( this),  new TimeModule());
8        }
9 }

setBaseApplicationInjector 最后一个參数是变參能够注冊多个Module

 1  public  class TimeModule  implements Module {
 2 
 3         @Override
 4          public  void configure(Binder binder) {
 5                 // 顺序无关，在详细的Activity中 被创建
 6                 binder
 7          .bind(ITimeService.  class)
 8          .to(AndroidTimeRead.  class);
 9            // .in(Singleton.class); // 单件
10          
11          binder.bind(ITimeRepository.  class)
12          .to(TimeRepository.  class);
13 
14        }
15 
16 }

binder 用于指定接口和详细的实现的映射，

这里仍旧依赖一个问题，就是  AndroidTimeRead 对 ITimeRepository 的依赖须要指定。

这样的复杂类型须要使用Provider来指定。

能够直接在 TimeModule 加入例如以下方法：

  1                @Provides

2        AndroidTimeRead getAndroidTimeRead(ITimeRepository rep){
3                 return  new AndroidTimeRead(rep);
4        }

主要是通过@Provides。

 除此以外还能够通过实现Provider<T> 接口实现。

 1  public  class AndroidTimeReadProvider  implements Provider<AndroidTimeRead> {
 2 
 3         @Inject
 4        ITimeRepository rep;
 5 
 6         @Override
 7          public AndroidTimeRead get() {
 8 
 9                 return  new AndroidTimeRead( rep );
10        }
11 
12 }

相应的在 Module加入 AndroidTimeRead的Bind

       1     @Override

 2          public  void configure(Binder binder) {
 3                 // 顺序无关，在详细的Activity中 被创建
 4                 binder
 5          .bind(ITimeService.  class )
 6          .to(AndroidTimeRead.  class );
 7            // .in(Singleton.class); // 单件
 8          
 9          binder.bind(ITimeRepository.  class )
10          .to(TimeRepository.  class );
11         
12          binder.bind(AndroidTimeRead.  class )
13          .toProvider(AndroidTimeReadProvider.  class );
14 
15        }

      

引入注入框架须要的思考：