Чем Transfuse отличается от Dagger?

Начнем с того, что я являюсь основным автором Transfuse, поэтому этот ответ может быть немного искажен в этом направлении.

И Transfuse, и Dagger одинаково обрабатывают внедрение зависимостей/инверсию управления для Android. Оба используют обработку аннотаций во время компиляции через JSR269 для генерации кода, поддерживающего DI/ Функционал МОК. Это позволяет им избежать дорогостоящего анализа на основе отражения во время выполнения, обычно связанного с контейнерами DI, которые можно найти в Java, отличной от Android. Не вдаваясь в подробности, Dagger и Transfuse действительно подходят к генерации кода существенно по-разному, что отражается на особенностях библиотек. Кроме того, Transfuse и Dagger используют общие аннотации JSR330 (@Inject, Provider, так далее). Это означает, что они оба следуют схеме внедрения в стиле Guice.

Вот как вы создаете граф объектов в Dagger:

public class DaggerActivity extends Activity {

    @Inject Example example;

    @Override protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ObjectGraph.create().inject(this);
        //do something else...
    }
}

Эквивалентный код в Transfuse использует функциональность @Factory:

@Factory
public interface Injector {
    Example get();
}

public class TransfuseActivity extends Activity {

    Example example;

    @Override protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        example = Factories.get(Injector.class).get();
        //do something else...
    }
}

Однако Transfuse предназначен для использования следующим образом, используя компоненты POJO, события жизненного цикла и т. д.:

@Activity
public class TransfuseActivity{

    @Inject Example example;

    @OnCreate public void doSomethingElse(){
        //do something else...
    }
}

Вот некоторые небольшие различия в движке DI в Transfuse и Dagger:

1. Transfuse поддерживает (насколько это возможно) циклические зависимости, Dagger целенаправленно выдает исключение в этом случае.
2. Transfuse удовлетворяет требованиям JSR330, а Dagger — нет. Разработчики Dagger хотели ошибиться в сторону простоты, избегая внедрения методов, что позволило им избежать нескольких запутанных случаев (ссылка).
3. Dagger имеет движок на основе отражения для случаев, когда код не был сгенерирован. Transfuse не требует и требует генерации кода (запуск процессора аннотаций) для работы.
4. Transfuse будет внедряться в частные поля, конструкторы, методы (не обязательно рекомендуется из-за накладных расходов на отражение). В этом случае Dagger выдает исключение.
5. Dagger напрямую использует модули, отражая возможности Guice. Каждый раз, когда вы создаете граф объектов, вам предоставляется возможность настроить его с помощью класса модуля, то есть: ObjectGraph.create(new DripCoffeeModule()). Модуль конфигурации Transfuse немного отличается, так как он включается в приложение во время компиляции. Каждый модуль в Transfuse является глобальным для проекта (это может измениться в будущих версиях Transfuse, но пока это не было проблемой для использования Transfuse).
6. Синглтоны в Dagger относятся к графу объектов, а синглтоны в Transfuse являются глобальными для приложения.

Большая разница между Dagger и Transfuse заключается в том, что Dagger ориентирован на то, чтобы быть простой библиотекой внедрения зависимостей, в то время как Transfuse фокусируется на «сделать Android лучше API, используя методы, чувствительные к производительности"

Transfuse поддерживает эти возможности, а также DI:

1. POJO-компоненты
2. Управление манифестами
3. Инъекции в стиле Roboguice/Butterknife
4. Облегченная система событий (@Observes, @OnCreate и т. д.)
5. АОП

Я бы порекомендовал, если вам интересно, попробовать Transfuse. Лично я хотел бы услышать о вашем опыте сравнения его с Dagger. У нас есть список рассылки, где вы можете поделиться с сообществом через документацию на веб-сайте.