Android'in önerilen uygulama mimarisi, endişelerin birbirinden ayrılmasından faydalanmak için kodunuzun sınıflara ayrılmasını teşvik eder. Bu ilkeyle, hiyerarşideki her sınıfın tek bir sorumluluğu vardır. Bu da birbirlerinin bağımlılıklarını karşılamak için birbirine bağlanması gereken daha çok sayıda küçük sınıfa işaret eder.

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 temsil edilebilir. Uygulama grafiğini tüm sınıflarınız ve bunların bağımlılıkları temsil eder.
Şekil 1'de, uygulama grafiğinin bir soyutlamasını görebilirsiniz.
A sınıfı (ViewModel
) B sınıfının (Repository
) bağımlı olduğu durumlarda 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ı ViewModel
öğesini test ederken farklı durumları test etmek için sahte veya taklitlerle farklı Repository
uygulamalarını geçirebilirsiniz.
Manuel bağımlılık yerleştirmeyle ilgili temel bilgiler
Bu bölümde, gerçek bir Android uygulaması senaryosunda manuel bağımlılık yerleştirme uygulaması açıklanmaktadır. Uygulamanızda bağımlılık yerleştirmeyi kullanmaya nasıl başlayabileceğinizle ilgili tekrarlanan bir yaklaşımdan bahseder. Yaklaşım, Dagger'ın sizin için otomatik olarak oluşturduğuna çok benzer 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 ekran grubu olarak düşünün. Giriş, kayıt ve ödeme aşamalarının tümü akışlara örnektir.
Tipik bir Android uygulamasının giriş akışını kapsarken LoginActivity
, LoginViewModel
, dolayısıyla UserRepository
'a bağlıdır.
UserRepository
ise bir Retrofit
hizmetine bağlı olan bir UserLocalDataSource
ve bir UserRemoteDataSource
'ye 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:
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
şöyle 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:
Çok sayıda standart kod var. Kodun başka bir bölümünde başka bir
LoginViewModel
örneği oluşturmak isterseniz kod tekrarlamanız gerekir.Bağımlılıklar sırayla bildirilmelidir. Oluşturmak için
UserRepository
örneğiniLoginViewModel
öncesinde belirtmeniz gerekir.Nesneleri yeniden kullanmak zordur.
UserRepository
öğesini birden fazla özellikte yeniden kullanmak istiyorsanız singleton kalıbını izlemeniz gerekir. Tekli kalıbı, tüm testler aynı tekil örneği paylaştığından testi zorlaştırır.
Bağımlılıkları 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 kapsayıcı sınıfınızı oluşturabilirsiniz. Bu container tarafından sağlanan tüm örnekler herkese açık olabilir. Bu örnekte, yalnızca bir UserRepository
örneğine ihtiyacınız olduğu için bağımlılıklarını gizli hale getirebilir ve gelecekte herkese açık hale getirmeyi tercih edebilirsiniz:
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 tüm uygulama genelinde kullanıldığından, bunların tüm etkinliklerin kullanabileceği ortak bir yere yerleştirilmesi 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 AppContainer
örneğini uygulamadan alabilir ve UserRepository
örneğinin paylaşımını 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, bir tekil UserRepository
olmaz. 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
örnekleri 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 aşağıdaki gibi görünür:
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 dahil edip LoginActivity
tarafından kullanılması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 iyi olsa da göz önünde bulundurulması gereken bazı zorluklar vardır:
Tüm bağımlılıklar için manuel olarak örnekler oluşturarak
AppContainer
aracını kendiniz yönetmeniz gerekir.Hala çok sayıda ortak kod var. Bir nesneyi yeniden kullanmak isteyip istemediğinize bağlı olarak fabrikaları veya parametreleri elle oluşturmanız gerekir.
Uygulama akışlarındaki bağımlılıkları yönetme
Projeye daha fazla işlev dahil etmek istediğinizde AppContainer
karmaşık hale gelir. Uygulamanız büyüyüp farklı özellik akışları sunmaya başladığınızda daha da fazla sorun ortaya çıkabilir:
Farklı akışlarınız olduğunda, nesnelerin sadece söz konusu akış kapsamında yaşamasını isteyebilirsiniz. Örneğin,
LoginUserData
oluştururken (yalnızca giriş akışında kullanılan kullanıcı adı ve şifreden oluşabilir) farklı bir kullanıcının eski giriş akışına ait verileri saklamak istemezsiniz. Her yeni akış için yeni bir örnek istersiniz. Bunu, bir sonraki kod örneğinde gösterildiği gibiAppContainer
içindeFlowContainer
nesneleri oluşturarak yapabilirsiniz.Uygulama grafiğini ve akış kapsayıcılarını optimize etmek 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ı ister:
Giriş akışı bitene kadar paylaşılması gereken aynı
LoginUserData
örneğine erişin.Akış yeniden başladığında yeni bir
LoginUserData
örneği oluşturun.
Bunu bir giriş akış kapsayıcısıyla sağlayabilirsiniz. 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şturabilmek
istersiniz. Bu nedenle, örneği bir tekil
hale getirmek yerine, giriş akışının AppContainer
'dan ihtiyaç duyduğu bağımlılıkları içeren bir
sınıf haline getirin.
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 container'a sahip olduğunuzda, container örneğini ne zaman oluşturup sileceğinize karar vermeniz gerekir. Giriş akışınız bir etkinlikten (LoginActivity
) bağımsız olduğundan, etkinlik söz konusu container'ın yaşam döngüsünü yöneten etkinliktir. LoginActivity
, örneği onCreate()
içinde oluşturabilir ve onDestroy()
içinde 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ı, AppContainer
üzerinden LoginContainer
öğesine erişebilir ve paylaşılan LoginUserData
örneğini kullanabilir.
Bu durumda görüntüleme yaşam döngüsü mantığıyla uğraşacağınız için yaşam döngüsü gözlemini kullanmak mantıklıdı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şmak için ve fabrikaları kullanarak sınıf örnekleri oluşturmak üzere 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 yatkın olabilir. Ayrıca, bellekte yer açmak için artık gerekli olmayan container'ları optimize edip atarak container'ların kapsamını ve yaşam döngüsünü kendiniz yönetmeniz gerekir. Bu işlemi yanlış yapmak, uygulamanızda küçük hatalara ve bellek sızıntılarına yol açabilir.
Dagger bölümünde, bu süreci otomatikleştirmek ve normalde elle yazacağınız kodu oluşturmak için Dagger'ı nasıl kullanabileceğinizi öğreneceksiniz.