Manuel bağımlı yerleştirme

Android'in önerilen uygulama mimarisi, endişelerinizin ayrılmasından yararlanmak için kodunuzun sınıflara ayrılmasını teşvik eder. Bu ilke, hiyerarşideki her sınıfın tanımlı tek bir sorumluluğun olduğu bir ilkedir. Bu durum, birbirlerinin bağımlılıklarını karşılamak için birbirine bağlanması gereken daha fazla sayıda küçük sınıfın oluşmasını sağlar.

Sınıflar arasındaki bağımlılıklar, her sınıfın bağlı olduğu sınıflara bağlı olduğu bir grafik olarak gösterilebilir. Tüm sınıflarınızın ve bunların bağımlılıklarının temsili uygulama grafiğini oluşturur. Şekil 1'de, uygulama grafiğinin bir özetini görebilirsiniz. A sınıfı (ViewModel) B sınıfına (Repository) bağlı olduğunda bu bağımlılığı temsil eden A'dan B'ye doğru bir çizgi vardır.

Bağımlılık ekleme, bu bağlantıların kurulmasına yardımcı olur ve uygulamaları test amacıyla değiştirmenizi sağlar. Örneğin, bir depoya bağlı bir ViewModel öğesini test ederken farklı durumları test etmek için sahteler veya taklitler ile farklı Repository uygulamalarını geçirebilirsiniz.

Manuel bağımlılık eklemeyle ilgili temel bilgiler

Bu bölümde, gerçek bir Android uygulaması senaryosunda manuel bağımlılık eklemenin nasıl uygulanacağı ele alınmaktadır. Uygulamanızda bağımlılık yerleştirmeyi kullanmaya nasıl başlayabileceğinize dair tekrarlanan bir yaklaşım üzerinden ilerler. Yaklaşım, Dagger'ın sizin için otomatik olarak oluşturduğu noktaya çok benzer bir noktaya ulaşana kadar iyileşir. Dagger hakkında daha fazla bilgi edinmek için Dagger ile ilgili temel bilgiler başlıklı makaleyi okuyun.

Akışı, uygulamanızda bir özelliğe karşılık gelen ekran grubu olarak düşünebilirsiniz. Giriş, kayıt ve ödeme aşamaları birer akış örneğidir.

Tipik bir Android uygulaması için giriş akışı kapsamındayken LoginActivity, LoginViewModel, dolayısıyla UserRepository öğesine bağlıdır. Daha sonra UserRepository, bir Retrofit hizmetine bağlı olan UserLocalDataSource ve UserRemoteDataSource öğelerine bağlıdır.

LoginActivity, giriş akışının giriş noktasıdır ve kullanıcı etkinlikle etkileşimde bulunur. Bu nedenle, LoginActivity ürününün tüm bağımlılıklarıyla LoginViewModel öğesini oluşturması gerekir.

Akışın Repository ve DataSource sınıfları aşağıdaki gibi görünür:

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

class UserLocalDataSource { ... }
class UserRemoteDataSource(
    private val loginService: LoginRetrofitService
) { ... }

class UserLocalDataSource {
    public UserLocalDataSource() { }
    ...
}

class UserRemoteDataSource {

    private final Retrofit retrofit;

    public UserRemoteDataSource(Retrofit retrofit) {
        this.retrofit = retrofit;
    }

    ...
}

class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

    public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
        this.userLocalDataSource = userLocalDataSource;
        this.userRemoteDataSource = userRemoteDataSource;
    }

    ...
}

LoginActivity şöyle görünür:

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // In order to satisfy the dependencies of LoginViewModel, you have to also
        // satisfy the dependencies of all of its dependencies recursively.
        // First, create retrofit which is the dependency of UserRemoteDataSource
        val retrofit = Retrofit.Builder()
            .baseUrl("https://example.com")
            .build()
            .create(LoginService::class.java)

        // Then, satisfy the dependencies of UserRepository
        val remoteDataSource = UserRemoteDataSource(retrofit)
        val localDataSource = UserLocalDataSource()

        // Now you can create an instance of UserRepository that LoginViewModel needs
        val userRepository = UserRepository(localDataSource, remoteDataSource)

        // Lastly, create an instance of LoginViewModel with userRepository
        loginViewModel = LoginViewModel(userRepository)
    }
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // In order to satisfy the dependencies of LoginViewModel, you have to also
        // satisfy the dependencies of all of its dependencies recursively.
        // First, create retrofit which is the dependency of UserRemoteDataSource
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://example.com")
                .build()
                .create(LoginService.class);

        // Then, satisfy the dependencies of UserRepository
        UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
        UserLocalDataSource localDataSource = new UserLocalDataSource();

        // Now you can create an instance of UserRepository that LoginViewModel needs
        UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

        // Lastly, create an instance of LoginViewModel with userRepository
        loginViewModel = new LoginViewModel(userRepository);
    }
}

Bu yaklaşımla ilgili sorunlar vardır:

1. Çok sayıda standart kod vardır. Kodun başka bir bölümünde başka bir LoginViewModel örneği oluşturmak isterseniz kod tekrarını kullanmanız gerekir.

2. Bağımlıların sırayla beyan edilmesi gerekir. Oluşturmak için LoginViewModel öncesinde UserRepository örneğini oluşturmanız gerekir.

3. Nesneleri yeniden kullanmak zordur. UserRepository öğesini birden fazla özellikte yeniden kullanmak isterseniz singleton kalıbına uyması gerekir. Tekil kalıp kalıbı, tüm testler aynı tekil tekil örneğini paylaştığından testi daha da zorlaştırır.

Bağımlıları bir container ile yönetme

Nesneleri yeniden kullanma sorununu çözmek için bağımlılıkları almak amacıyla kullandığınız kendi bağımlılık container sınıfınızı oluşturabilirsiniz. Bu container'ın sağladığı tüm örnekler herkese açık olabilir. Bu örnekte, yalnızca UserRepository örneğine ihtiyacınız olduğundan bağımlılıklarını, gelecekte sağlanması gerekirse herkese açık hale getirme seçeneğiyle gizli hale getirebilirsiniz:

// Container of objects shared across the whole app
class AppContainer {

    // Since you want to expose userRepository out of the container, you need to satisfy
    // its dependencies as you did before
    private val retrofit = Retrofit.Builder()
                            .baseUrl("https://example.com")
                            .build()
                            .create(LoginService::class.java)

    private val remoteDataSource = UserRemoteDataSource(retrofit)
    private val localDataSource = UserLocalDataSource()

    // userRepository is not private; it'll be exposed
    val userRepository = UserRepository(localDataSource, remoteDataSource)
}

// Container of objects shared across the whole app
public class AppContainer {

    // Since you want to expose userRepository out of the container, you need to satisfy
    // its dependencies as you did before
    private Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://example.com")
            .build()
            .create(LoginService.class);

    private UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
    private UserLocalDataSource localDataSource = new UserLocalDataSource();

    // userRepository is not private; it'll be exposed
    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);
}

Bu bağımlılıklar uygulamanın tamamında kullanıldığından, tüm etkinliklerin kullanabileceği ortak bir yere, yani Application sınıfına yerleştirilmesi gerekir. AppContainer örneği içeren özel bir Application sınıfı oluşturun.

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
class MyApplication : Application() {

    // Instance of AppContainer that will be used by all the Activities of the app
    val appContainer = AppContainer()
}

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
public class MyApplication extends Application {

    // Instance of AppContainer that will be used by all the Activities of the app
    public AppContainer appContainer = new AppContainer();
}

Artık AppContainer örneğini uygulamadan alabilir ve UserRepository örneğinin paylaşılan kısmını alabilirsiniz:

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Gets userRepository from the instance of AppContainer in Application
        val appContainer = (application as MyApplication).appContainer
        loginViewModel = LoginViewModel(appContainer.userRepository)
    }
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Gets userRepository from the instance of AppContainer in Application
        AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
        loginViewModel = new LoginViewModel(appContainer.userRepository);
    }
}

Bu şekilde, bir tekil UserRepository sahibi olmazsınız. Bunun yerine, grafikteki nesneleri içeren ve bu nesnelerin diğer sınıfların tüketebileceği örneklerini oluşturan tüm etkinliklerde paylaşılan bir AppContainer'nız olur.

LoginViewModel uygulamasının uygulamanın daha fazla yerinde kullanılması gerekiyorsa LoginViewModel örneklerini oluşturduğunuz merkezi bir yere sahip olmak mantıklıdır. LoginViewModel oluşturma işlemini container'a taşıyabilir ve bir fabrika aracılığıyla bu türden yeni nesneler sağlayabilirsiniz. LoginViewModelFactory kodu şu şekilde görünür:

// Definition of a Factory interface with a function to create objects of a type
interface Factory<T> {
    fun create(): T
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory(private val userRepository: UserRepository) : Factory {
    override fun create(): LoginViewModel {
        return LoginViewModel(userRepository)
    }
}

// Definition of a Factory interface with a function to create objects of a type
public interface Factory<T> {
    T create();
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory implements Factory {

    private final UserRepository userRepository;

    public LoginViewModelFactory(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public LoginViewModel create() {
        return new LoginViewModel(userRepository);
    }
}

LoginViewModelFactory öğesini AppContainer içine ekleyip LoginActivity tarafından kullanılmasını sağlayabilirsiniz:

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
class AppContainer {
    ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)

    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Gets LoginViewModelFactory from the application instance of AppContainer
        // to create a new LoginViewModel instance
        val appContainer = (application as MyApplication).appContainer
        loginViewModel = appContainer.loginViewModelFactory.create()
    }
}

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
public class AppContainer {
    ...

    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

    public LoginViewModelFactory loginViewModelFactory = new LoginViewModelFactory(userRepository);
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Gets LoginViewModelFactory from the application instance of AppContainer
        // to create a new LoginViewModel instance
        AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
        loginViewModel = appContainer.loginViewModelFactory.create();
    }
}

Bu yaklaşım bir öncekinden daha iyi olsa da dikkate alınması gereken bazı zorluklar var:

1. Tüm bağımlılıklar için elle örnekler oluşturarak AppContainer öğesini kendiniz yönetmeniz gerekir.

2. Hâlâ çok sayıda ortak kod var. Bir nesneyi yeniden kullanmak isteyip istemediğinize bağlı olarak fabrikaları veya parametreleri manuel olarak oluşturmanız gerekir.

Uygulama akışlarındaki bağımlılıkları yönetme

AppContainer, projeye daha fazla işlev eklemek istediğinizde karmaşık hale gelir. Uygulamanız büyüyüp farklı özellik akışları sunmaya başladığınızda daha da fazla sorun ortaya çıkar:

1. Farklı akışlarınız olduğunda, nesnelerin yalnızca söz konusu akışın kapsamında yaşamasını isteyebilirsiniz. Örneğin, LoginUserData oluştururken (yalnızca giriş akışında kullanılan kullanıcı adı ve şifreden oluşabilecek) farklı bir kullanıcının eski giriş akışındaki verileri saklamak istemezsiniz. Her yeni akış için yeni bir örnek istiyorsunuz. Bunu, bir sonraki kod örneğinde gösterildiği gibi AppContainer içinde FlowContainer nesneleri oluşturarak yapabilirsiniz.

2. Uygulama grafiğinin ve akış kapsayıcılarının optimize edilmesi de zor olabilir. İçinde bulunduğunuz akışa bağlı olarak ihtiyacınız olmayan örnekleri silmeyi unutmamanız gerekir.

Bir etkinlik (LoginActivity) ve birden çok parçadan (LoginUsernameFragment ve LoginPasswordFragment) oluşan bir giriş akışınız olduğunu varsayalım. Bu görünümler şunları yapmak ister:

1. Giriş akışı bitene kadar paylaşılması gereken LoginUserData örneğine erişin.

2. Akış yeniden başladığında yeni bir LoginUserData örneği oluşturun.

Bunu bir giriş akışı kapsayıcısıyla yapabilirsiniz. Giriş akışı başladığında bu container'ın oluşturulması ve akış sona erdiğinde bellekten kaldırılması gerekir.

Örnek koda bir LoginContainer ekleyelim. Uygulamada birden fazla LoginContainer örneği oluşturmak istiyorsanız bu örneği tekil yapmak yerine, giriş akışının AppContainer ile ihtiyaç duyduğu bağımlılıkların olduğu bir sınıf haline getirin.

class LoginContainer(val userRepository: UserRepository) {

    val loginData = LoginUserData()

    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

// AppContainer contains LoginContainer now
class AppContainer {
    ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)

    // LoginContainer will be null when the user is NOT in the login flow
    var loginContainer: LoginContainer? = null
}

// Container with Login-specific dependencies
class LoginContainer {

    private final UserRepository userRepository;

    public LoginContainer(UserRepository userRepository) {
        this.userRepository = userRepository;
        loginViewModelFactory = new LoginViewModelFactory(userRepository);
    }

    public LoginUserData loginData = new LoginUserData();

    public LoginViewModelFactory loginViewModelFactory;
}

// AppContainer contains LoginContainer now
public class AppContainer {
    ...
    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

    // LoginContainer will be null when the user is NOT in the login flow
    public LoginContainer loginContainer;
}

Bir akışa özel container'ınız olduğunda container örneğini ne zaman oluşturup sileceğinize karar vermeniz gerekir. Giriş akışınız bir etkinlikte (LoginActivity) bağımsız olduğundan etkinlik, ilgili container'ın yaşam döngüsünü yöneten etkinliktir. LoginActivity, örneği onCreate() içinde oluşturup onDestroy() içinde silebilir.

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel
    private lateinit var loginData: LoginUserData
    private lateinit var appContainer: AppContainer


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        appContainer = (application as MyApplication).appContainer

        // Login flow has started. Populate loginContainer in AppContainer
        appContainer.loginContainer = LoginContainer(appContainer.userRepository)

        loginViewModel = appContainer.loginContainer.loginViewModelFactory.create()
        loginData = appContainer.loginContainer.loginData
    }

    override fun onDestroy() {
        // Login flow is finishing
        // Removing the instance of loginContainer in the AppContainer
        appContainer.loginContainer = null
        super.onDestroy()
    }
}

public class LoginActivity extends Activity {

    private LoginViewModel loginViewModel;
    private LoginData loginData;
    private AppContainer appContainer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        appContainer = ((MyApplication) getApplication()).appContainer;

        // Login flow has started. Populate loginContainer in AppContainer
        appContainer.loginContainer = new LoginContainer(appContainer.userRepository);

        loginViewModel = appContainer.loginContainer.loginViewModelFactory.create();
        loginData = appContainer.loginContainer.loginData;
    }

    @Override
    protected void onDestroy() {
        // Login flow is finishing
        // Removing the instance of loginContainer in the AppContainer
        appContainer.loginContainer = null;

        super.onDestroy();
    }
}

LoginActivity gibi giriş parçaları da AppContainer üzerinden LoginContainer öğesine erişebilir ve paylaşılan LoginUserData örneğini kullanabilir.

Çünkü bu durumda görüntüleme yaşam döngüsü mantığıyla uğraşacağınızdan yaşam döngüsü gözlemini kullanmak mantıklı olacaktır.

Sonuç

Bağımlılık yerleştirme, ölçeklenebilir ve test edilebilir Android uygulamaları oluşturmak için iyi bir tekniktir. Container'ları, uygulamanızın farklı bölümlerindeki sınıf örneklerini paylaşmanın bir yolu ve fabrikaları kullanarak sınıf örnekleri oluşturmak için merkezi bir yer olarak kullanın.

Uygulamanız büyüdükçe, çok sayıda standart kod (fabrikalar gibi) yazdığınızı görmeye başlarsınız ve bu da hataya açık olabilir. Ayrıca, bellekte yer açmak için artık ihtiyaç duyulmayan container'ları optimize edip yok ederek container'ların kapsamını ve yaşam döngüsünü kendiniz yönetmeniz gerekir. Bunun yanlış yapılması uygulamanızda küçük hatalara ve bellek sızıntılarına yol açabilir.

Dagger bölümünde, bu işlemi otomatikleştirmek ve normalde elle yazacağınız kodu oluşturmak için Dagger'ı nasıl kullanabileceğinizi öğreneceksiniz.