java - 如何在 Dagger 1.x 中使用 Singleton？

Question

我读了 Christian Gruber 的 post我开始想知道如何使用应用程序范围的单例。
在我的应用程序中，我有一个类 DBHelper，其主要目的是保存数据库的 key 。我也有很多(至少两个)不同的 DAO。
现在 - 我看不出为什么我的几个 Activity/类需要的不仅仅是一个 DAO 实例。更重要的是，为什么 DAO 只需要一个 DBHelper 实例？我很确定他们可以共享，尤其是我不预测两个 DAO 想要同时对我的数据库执行某些操作的情况。那么让我们看看一些类:

• 数据库助手

  @Singleton
  public class DBHelper extends SQLiteOpenHelper {
        //some not relevant configuration stuff
        private Context context;
  
        @Inject
        public DBHelper(Context context) {
             super(context, DATABASE_NAME, null, DATABASE_VERSION);
             this.context = context;
        }
  
       @Override
       public void onCreate(SQLiteDatabase db) {
            //db.execSQL, creating tables and stuff
       }
  
       @Override
       public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            //dropping tables, creating a new one
            onCreate(db);
       }
  }
  

• DAO 示例

      public interface SomeDataDAO {
          void hai();
      }
  
      public class SomeDataDAOImpl implements SomeDataDAO {
           private DBHelper dbHelper;
  
           public SomeDataDAOImpl(DBHelper dbHelper){
                 this.dbHelper = dbHelper;
           }
           @Override
           public void hai() {
                SQLiteDatabase database = dbHelper.getWritableDatabase();
                dbHelper.doSomeDatabaseStuff()
           }
      }
  

• 一些数据模块

  @Module(
          injects = { MainActivity.class, SomeServiceImpl.class }
          )
  public class SomeDataModule {
        private Context appContext;
  
        @Provides @Singleton
        public SomeDataDAO provideSomeDataDao(DBHelper dbHelper){
              return new SomeDataDAOImpl(dbHelper);
        }
  
        @Provides @Singleton
        public ISomeService provideSomeService(SomeServiceImpl impl){
               return impl;
        }
  
        @Provides
        public Context getAppContext(){
               return this.appContext;
        }
        public SomeDataModule(){
               this.appContext = MainActivity.getAppContext();
        }
  }
  

• 现在让我们看两个依赖消费者的例子

  public class MainActivity extends ActionBarActivity {
      @Inject
      SomeDataDAO someDataDAO;
      private ObjectGraph objectGraph;
      @Inject
      ISomeService someService;
      private static Context appContext;
  
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           appContext = getApplicationContext();
           objectGraph = ObjectGraph.create(SomeDataModule.class);
           objectGraph.inject(this);
           someService.doSomeStuff();
      }
  
     public static Context getAppContext() {
           return appContext;
     }
  }
  

  
  

  public class SomeServiceImpl implements ISomeService {
      private ObjectGraph objectGraph;
      @Inject public SomeDataDAO someDataDAO;
  
      public SomeServiceImpl(){
          objectGraph = ObjectGraph.create(GraphDataModule.class);
          objectGraph.inject(this);
      }
  
      public void doSomeStuff(){
           someDataDAO.hai();
      }
  
  }
  

它有效，但是当我 inject(this) 两次时，Dagger 显然为我创建了两个 DBHelper 实例，因为它认为“一个单例 fon 一个图形实例”。如何将我的 SomeDataModule 包装在 ApplicationModule 中，以便在整个应用程序中只有一个 DBHelper 实例？不幸的是，将 @Singleton 添加到 DBHelper 是不够的。

Answer 1

解决一个小设计缺陷的简单、简短的答案如下。与其创建一个新的 ObjectGraph 来将 SomeDataDAO 实例注入(inject)到您的 SomeServiceImpl 中，不如将 SomeDataDAO 传递给你的构造函数。这实际上就是依赖注入(inject)的典型含义:使用某个对象的构造函数来注入(inject)其依赖项:

public class SomeServiceImpl implements ISomeService {

    private final SomeDataDAO someDataDAO;

    @Inject
    public SomeServiceImpl(SomeDataDAO someDataDAO){
        this.someDataDAO = someDataDAO;
    }

    public void doSomeStuff(){
         someDataDAO.hai();
    }
}

现在这就是魔法发生的地方。注意到构造函数的 @Inject 注释了吗？它告诉 Dagger 在请求 SomeServiceImpl 实例时使用此构造函数，并查询 ObjectGraph 以获取其参数。

所以当你在下面得到这个Provides方法时，Dagger已经知道SomeServiceImpl依赖于SomeDataDAO，并使用你的 provideSomeDataDAO 方法来提供那个实例。而且，嘿，它是一个单例，所以这与此 ObjectGraph 检索的 SomeDataDAO 的任何其他实例完全相同!

  @Provides @Singleton
  public ISomeService provideSomeService(SomeServiceImpl impl){
         return impl;
  }

---

实际上，您并不想太频繁地使用ObjectGraph.inject(...)，您实际上是想使用上述方法。然而，在某些情况下，您无法决定构造函数的外观。例如在 Android 中，这些是 Activity 和 View 类，等等。对于这些特殊情况，创建了 ObjectGraph.inject，因此您仍然可以使用 Dagger 注入(inject)依赖项。

最后说明:在 SomeServiceImpl 中，我已将 someDataDAO 设为私有(private)。您可能知道，这是处理实例字段的首选方式，使用可注入(inject)构造函数可以实现这一点。

_{原来这个答案一点也不短 :O)}