Manuel bağımlı yerleştirme

Android'in önerdiği uygulama mimarisi, kodunuzu sınıflara ayırarak sorumlulukların ayrılmasından yararlanmanızı önerir. Bu, hiyerarşinin her sınıfının tek bir tanımlanmış sorumluluğu olduğu bir ilkedir. Bu, birbirlerinin bağımlılığını karşılamak için birbirine bağlanması gereken daha fazla küçük sınıfa yol açar.

Android uygulamaları genellikle birçok sınıftan oluşur ve bunların bazıları birbirine bağlıdır.
Şekil 1. Android uygulamasının uygulama grafiğinin modeli

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. 1. şekilde, uygulama grafiğinin soyut bir temsilini görebilirsiniz. A sınıfı (ViewModel), B sınıfına (Repository) bağlı olduğunda bu bağımlılığı gösteren A'dan B'ye doğru bir çizgi bulunur.

Bağımlılık ekleme, bu bağlantıların kurulmasına yardımcı olur ve test için uygulamaları değiştirmenize olanak tanır. Örneğin, bir depoya bağlı bir ViewModel sınıfını test ederken farklı durumları test etmek için Repository sınıfının sahte veya taklit sürümlerini iletebilirsiniz.

Manuel bağımlılık eklemenin temelleri

Bu bölümde, gerçek bir Android uygulaması senaryosuna manuel bağımlılık eklemenin nasıl yapılacağı açıklanmaktadır. Bu makalede, uygulamanızda bağımlılık eklemeyi nasıl kullanmaya başlayabileceğinize dair yinelenen bir yaklaşım ele alınmaktadır. Yaklaşım, Dagger'ın sizin için otomatik olarak oluşturacağı noktaya çok benzeyen bir noktaya ulaşana kadar iyileştirilir. Dagger hakkında daha fazla bilgi için Dagger ile ilgili temel bilgiler başlıklı makaleyi okuyun.

Akış, uygulamanızda bir özelliğe karşılık gelen ekranlar grubudur. Giriş, kayıt ve ödeme, akışlara örnek gösterilebilir.

Tipik bir Android uygulamasının giriş akışını ele alırken LoginActivity, LoginViewModel'a bağlıdır. LoginViewModel ise UserRepository'ye bağlıdır. Ardından UserRepository, bir UserLocalDataSource ve UserRemoteDataSource öğesine bağlıdır. Bu öğeler de Retrofit hizmetine bağlıdır.

LoginActivity, giriş akışına giriş noktasıdır ve kullanıcı etkinlikle etkileşim kurar. Bu nedenle, LoginActivity'ün tüm bağımlılıklarıyla birlikte LoginViewModel'ü oluşturması gerekir.

Akıştaki Repository ve DataSource sınıfları şu şekilde görünür:

Kotlin

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

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

Java

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 aşağıdaki gibi görünür:

Kotlin

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)
    }
}

Java

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 fazla ortak metin kodu var. Kodun başka bir bölümünde LoginViewModel için başka bir örnek oluşturmak isterseniz kod yineleme olur.

  2. Bağımlılıkların sırayla bildirilmesi gerekir. Oluşturmak için LoginViewModel'dan önce UserRepository'yi örneklemeniz gerekir.

  3. Nesneleri yeniden kullanmak zordur. UserRepository sınıfını birden fazla özellikte yeniden kullanmak isterseniz tekil örnek kalıbına uyması gerekir. Tekil nesne kalıbı, tüm testler aynı tekil nesne örneğini paylaştığı için testleri daha zor hale getirir.

Bağımlılıkları kapsayıcıyla yönetme

Nesneleri yeniden kullanma sorununu çözmek için bağımlılıkları almak üzere kullanacağınız kendi bağımlılıklar kapsayıcı sınıfınızı oluşturabilirsiniz. Bu kapsayıcı tarafından sağlanan tüm örnekler herkese açık olabilir. Örnekte, yalnızca bir UserRepository örneğine ihtiyacınız olduğu için, sağlamanız gerekirse gelecekte herkese açık hale getirme seçeneğiyle bağımlılıkları gizli yapabilirsiniz:

Kotlin

// 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)
}

Java

// 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ığı için tüm etkinliklerin kullanabileceği ortak bir yere yerleştirilmeleri gerekir: Application sınıfı. AppContainer örneği içeren özel bir Application sınıfı oluşturun.

Kotlin

// 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()
}

Java

// 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 uygulamadan AppContainer örneğini alabilir ve paylaşılan UserRepository örneğini elde edebilirsiniz:

Kotlin

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)
    }
}

Java

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 tekil bir UserRepository olmaz. Bunun yerine, grafikteki nesneleri içeren ve bu nesnelerin diğer sınıfların kullanabileceği örneklerini oluşturan, tüm etkinliklerde paylaşılan bir AppContainer'iniz vardır.

LoginViewModel, uygulamanın daha fazla yerinde gerekiyorsa LoginViewModel örnekleri oluşturduğunuz merkezi bir yere sahip olmak mantıklı olur. LoginViewModel öğesinin oluşturulmasını kapsayıcıya taşıyabilir ve bu türdeki yeni nesnelere bir fabrika sağlayabilirsiniz. LoginViewModelFactory kodunun görünümü şu şekildedir:

Kotlin

// 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)
    }
}

Java

// 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 öğesinin bunu kullanmasını sağlayabilirsiniz:

Kotlin

// 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()
    }
}

Java

// 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 öncekinden daha iyidir ancak dikkate alınması gereken bazı zorluklar vardır:

  1. AppContainer'ü kendiniz yönetmeniz ve tüm bağımlılıklara ait örnekleri manuel olarak oluşturmanız gerekir.

  2. Hâlâ çok sayıda şablon 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üdükçe ve 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 ilgili akış kapsamında bulunmasını isteyebilirsiniz. Örneğin, LoginUserData (yalnızca giriş akışında kullanılan kullanıcı adı ve şifreyi içerebilir) oluştururken farklı bir kullanıcının eski giriş akışındaki verileri kalıcı olarak saklamak istemezsiniz. Her yeni akış için yeni bir örnek istiyorsunuz. Bunu, aşağıdaki kod örneğinde gösterildiği gibi AppContainer içinde FlowContainer nesneleri oluşturarak yapabilirsiniz.

  2. Uygulama grafiğini ve akış kapsayıcılarını optimize etmek de zor olabilir. Kullanmadığınız örnekleri, bulunduğunuz akışa bağlı olarak silmeyi unutmayın.

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

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

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

Bunu bir giriş akışı kapsayıcısıyla yapabilirsiniz. Bu kapsayıcının, giriş akışı başladığında 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 istediğiniz için sınıfı tekil yapmak yerine, giriş akışının AppContainer'dan ihtiyaç duyduğu bağımlılıkları içeren bir sınıf yapın.

Kotlin

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
}

Java

// 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 bir kapsayıcı oluşturduktan sonra kapsayıcı örneğini ne zaman oluşturacağınıza ve sileceğinize karar vermeniz gerekir. Giriş akışınız bir etkinlikte (LoginActivity) kendi kendine yeterli olduğundan, bu kapsayıcının yaşam döngüsünü etkinlik yönetir. LoginActivity, örneği onCreate()'te oluşturup onDestroy()'de silebilir.

Kotlin

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()
    }
}

Java

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'den LoginContainer'a erişebilir ve paylaşılan LoginUserData örneğini kullanabilir.

Bu durumda görünüm yaşam döngüsü mantığıyla uğraştığınız için yaşam döngüsü gözlemi kullanmak mantıklıdır.

Sonuç

Bağımlılık ekleme, ölçeklenebilir ve test edilebilir Android uygulamaları oluşturmak için iyi bir tekniktir. Uygulamanızın farklı bölümlerinde sınıf örneklerini paylaşmak için ve fabrikaları kullanarak sınıf örnekleri oluşturmak için merkezi bir yer olarak kapsayıcıları kullanın.

Uygulamanız büyüdükçe çok fazla standart kod (ör. fabrikalar) yazdığınızı ve bu kodların hatalara açık olabileceğini fark etmeye başlarsınız. Ayrıca, kapsayıcıların kapsamını ve yaşam döngüsünü kendiniz yönetmeniz, bellek alanı açmak için artık ihtiyaç duyulmayan kapsayıcıları optimize etmeniz ve silmeniz gerekir. Bu işlemi yanlış yapmak, uygulamanızda göze çarpmayan hatalara ve bellek sızıntılarına neden olabilir.

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