Manuel bağımlı yerleştirme

Android'in önerilen uygulama mimarisi, endişelerin ayrılmasından yararlanmak için kodunuzu sınıflara Bu yöntemde her hiyerarşi sınıfının tanımlanmış tek bir sorumluluğu olur. Bu durum, birbirine bağlanması gereken daha çok ve daha küçük sınıfların ortaya çıkmasına yol açıyor. birbirlerinin bağımlılıklarını karşılamaktır.

'nı inceleyin.

Sınıflar arasındaki bağımlılıklar bir grafik olarak gösterilebilir. Her bir sınıfı, bağlı olduğu sınıflara bağlıdır. Tüm sorumluluklarınızın temsili uygulama grafiğini oluşturur. Şekil 1'de, uygulama grafiğinin bir soyutlamasını 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 işaret eden bir çizgidir.

Bağımlılık yerleştirme, bu bağlantıları kurabilmenizi sağlar ve mevcut bağlantılarınızdan uygulamaları hakkında bilgi edindiniz. Örneğin, bir ViewModel bir depoya bağlı olarak farklı dosya uygulamaları Farklı durumları test etmek için sahte veya taklit ürün içeren Repository.

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

Bu bölümde, gerçek bir Android cihazda manuel bağımlılık ekleme işleminin nasıl uygulanacağı açıklanmaktadır. senaryomuzu konuşmaya başlayalım. Kurs, Çevik yaklaşımın nasıl işe yarayacağına ve en iyi uygulamaları paylaşacağız. Yaklaşım, şu hedefe ulaşana kadar iyileşir: için otomatik olarak oluşturacağına çok benzer bir nokta, siz. Dagger hakkında daha fazla bilgi edinmek için Dagger ile ilgili temel bilgiler başlıklı makaleyi okuyun.

Akış, uygulamanızda bir yayına karşılık gelen özelliğini kullanabilirsiniz. Giriş, kayıt ve ödeme işlemleri akışlara örnektir.

LoginActivity, tipik bir Android uygulamasının giriş akışını kapsarken LoginViewModel metriğine bağlıdır. Bu da UserRepository metriğine bağlıdır. Öte yandan UserRepository, UserLocalDataSource ve UserRemoteDataSource. Bu da Retrofit metriğine bağlıdır geliştirmenizi sağlar.

LoginActivity, giriş akışı ve kullanıcı için giriş noktasıdır. etkinlikle etkileşime girdiğini gösterir. Bu nedenle, LoginActivity Tüm bağımlılıklarıyla birlikte LoginViewModel.

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

1. Çok sayıda standart kod vardır. Başka bir örnek oluşturmak isterseniz LoginViewModel bölümüne yerleştirirseniz kod yinelenmiş olur.

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

3. Nesnelerin yeniden kullanılması zordur. UserRepository uygulamasını yeniden kullanmak isterseniz bu adımları uygulamak zorundaydınız, singleton kalıbı. Tekli kalıp, tüm testler aynı modeli aynı tekli örneğidir.

Bağımlılıkları bir container ile yönetme

Nesneleri yeniden kullanma sorununu çözmek için kendi görüntünüzü oluşturabilirsiniz dependencies container sınıfını kullanın. Tüm örnekler herkese açık hale getirilebilir. Bu örnekte, UserRepository örneğini kullanarak bağımlılarını gizli hale getirebilirsiniz. bunları gelecekte herkese açık olarak ayarlama seçeneği sunulur:

// 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ığı için tek bir yerde toplar: Application sınıfı. Özel oluştur AppContainer örneği içeren Application sınıfı.

// 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ı alın:

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 sayede, tek bir UserRepository adresiniz olmaz. Bunun yerine AppContainer, grafikteki nesnelerin bulunduğu tüm etkinlikler genelinde paylaşıldı ve bu nesnelerin diğer sınıfların kullanabileceği örnekleri oluşturur.

Uygulamada daha fazla yerde LoginViewModel gerekiyorsa LoginViewModel satışların örneklerini oluşturduğunuz merkezi bir yer olması gerekir. LoginViewModel oluşturma işlemini kapsayıcıya taşıyabilir ve bu nesnelere bir göz atalım. LoginViewModelFactory kodu şöyle 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 öğesine dahil edebilir ve LoginActivity tarafından tüketilir:

// 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 öncekinden daha iyi olsa da hâlâ bazı yaklaşımlar göz önünde bulundurulması gereken zorluklar:

1. AppContainer uygulamasını kendiniz yönetmeniz ve herkes için örnekler oluşturmanız gerekir başa çıkabileceksiniz.

2. Hâlâ birçok standart kod vardır. Fabrikalar oluşturmanız ya da parametrelerini manuel olarak kullanabilirsiniz.

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

Daha fazla işlev eklemek istediğinizde AppContainer karmaşık hale gelir. gösterir. Uygulamanız daha büyük hale geldiğinde ve siz de uygulamanızı farklı özellik akışları, ortaya çıkan daha fazla sorun vardır:

1. Farklı akışlarınız olduğunda, nesnelerin yalnızca aynı ortamda bu akışın kapsamını belirleyin. Örneğin, LoginUserData ( yalnızca giriş akışında kullanılan kullanıcı adı ve şifrenin olmaması) kullanın. Yeni bir her yeni akış için bir örneğidir. Bunu, FlowContainer oluşturarak yapabilirsiniz. nesnelerini (AppContainer) sonraki kod örneğinde gösterildiği gibi içine yerleştirin.

2. Uygulama grafiğini ve akış kapsayıcılarını optimize etmek de zor olabilir. bu akıştan en iyi şekilde yararlanabilirsiniz.

Bir etkinlikten (LoginActivity) oluşan bir giriş akışınız olduğunu varsayalım ve birden çok parça (LoginUsernameFragment ve LoginPasswordFragment) içerir. Bu görünümler şunları istiyor:

1. Şu tarihe kadar paylaşılması gereken LoginUserData örneğine erişin: sona ereceğini lütfen unutmayın.

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şturulur ve akış sona erdiğinde bellekten kaldırılır.

Örnek koda bir LoginContainer ekleyelim. Projenize göre uygulamada birden fazla LoginContainer örneği olması gerekir. Dolayısıyla bunu Singleton, giriş akışının ihtiyaç duyduğu bağımlılıkları içeren bir sınıf AppContainer.

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 özgü bir kapsayıcınız olduğunda, ne zaman oluşturacağınıza container örneğini silin. Çünkü giriş akışınız, bağımsız olarak bir etkinlik (LoginActivity) varsa yaşam döngüsünü yöneten etkinliktir anlamına gelir. LoginActivity, örneği onCreate() ve onDestroy() ürününden silebilirsiniz.

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 LoginContainer içine şuradan erişebilir: AppContainer ve paylaşılan LoginUserData örneğini kullanın.

Çünkü bu örnekte, görüntüleme yaşam döngüsü mantığını ele alıyor ve yaşam döngüsü gözlemi mantıklıdır.

Sonuç

Bağımlılık yerleştirme, ölçeklenebilir ve test edilebilir Android uygulamaları. Farklı sınıflardaki sınıfların örneklerini paylaşmak için kapsayıcıları kullanın tek bir merkezde toplayarak uygulamanızın farklı bölümlerinin örneklerini nasıl hazırladığımızı düşünün.

Uygulamanız büyüdüğünde, çok fazla yazdığınızı ortak metin kodu (fabrikalar gibi) olduğundan emin olun. Şunları da yapmanız gerekir: kapsam ve yaşam döngüsünü kendiniz yönetebilirsiniz. bellekte yer açmak için artık ihtiyaç duyulmayan container'ları silerek. Bunu yanlış yapmanız, uygulamanızda küçük hatalara ve bellek sızıntılarına neden olabilir.

Dagger bölümünde, süreci otomatikleştirmek ve aynı kodu oluşturmak için Dagger'ı nasıl kullanabileceğinizi öğrenin elle yazardınız.