การแทรกทรัพยากร Dependency ด้วยตนเอง

สถาปัตยกรรมแอปที่แนะนำของ Android ส่งเสริมให้เกิดการแบ่ง รหัสของคุณในชั้นเรียนเพื่อใช้ประโยชน์จากการแยกข้อกังวล หลักการ โดยที่แต่ละคลาสในลำดับชั้นมีหน้าที่รับผิดชอบเพียงหนึ่งเดียว จึงทำให้เกิดชั้นเรียนขนาดเล็กจำนวนมากขึ้นที่จำเป็นต้องเชื่อมต่อถึงกัน เพื่อเติมเต็ม ทรัพยากร Dependency ของกันและกัน

วันที่

ทรัพยากร Dependency ระหว่างคลาสต่างๆ สามารถแสดงเป็นกราฟ โดยแต่ละคลาส เชื่อมโยงกับชั้นเรียนที่ขึ้นอยู่กับชั้นเรียนนั้น การเป็นตัวแทนของพร็อพเพอร์ตี้ คลาสและทรัพยากร Dependency จะทําให้เป็นกราฟแอปพลิเคชัน ในรูปที่ 1 คุณจะเห็นกราฟของแอปพลิเคชันแบบนามธรรม เมื่อคลาส A (ViewModel) ขึ้นอยู่กับคลาส B (Repository) จะมี เส้นที่ชี้จาก A ถึง B แสดงถึงทรัพยากร Dependency นั้น

การแทรกทรัพยากร Dependency ช่วยสร้างการเชื่อมต่อเหล่านี้และช่วยให้คุณสลับตำแหน่งได้ การนำไปใช้งานในการทดสอบ เช่น เมื่อทดสอบ ViewModel ขึ้นอยู่กับที่เก็บ คุณสามารถส่งการนำไปใช้งาน Repository ด้วยเนื้อหาปลอมหรือล้อเลียนเพื่อทดสอบกรณีต่างๆ

ข้อมูลพื้นฐานเกี่ยวกับการแทรกทรัพยากร Dependency ด้วยตนเอง

ส่วนนี้จะครอบคลุมวิธีใช้การแทรกทรัพยากร Dependency ด้วยตนเองใน Android จริง สถานการณ์ของแอป ซึ่งอธิบายวิธีที่คุณจะเริ่ม โดยใช้การแทรกทรัพยากร Dependency ในแอป แนวทางนี้จะพัฒนาขึ้นจน จุดที่คล้ายกับที่ Dagger จะสร้างโดยอัตโนมัติสำหรับ ให้ทำงานแทนคุณ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Dagger โปรดอ่านข้อมูลเบื้องต้นเกี่ยวกับ Dagger

พิจารณาขั้นตอนว่าเป็นกลุ่มหน้าจอในแอปที่สอดคล้องกับ ตัวอย่างของขั้นตอนทั้งหมดคือการเข้าสู่ระบบ การลงทะเบียน และการเช็คเอาต์

เมื่อพูดถึงขั้นตอนการเข้าสู่ระบบสำหรับแอป Android ทั่วไป ระบบจะกำหนดให้ LoginActivity ขึ้นอยู่กับ LoginViewModel ซึ่งก็ขึ้นอยู่กับ UserRepository UserRepository จะขึ้นอยู่กับ UserLocalDataSource และ UserRemoteDataSource ซึ่งก็ขึ้นอยู่กับ Retrofit service.

LoginActivity คือจุดแรกเข้าของขั้นตอนการเข้าสู่ระบบและผู้ใช้ โต้ตอบกับกิจกรรม ดังนั้น LoginActivity จึงต้องสร้าง LoginViewModel พร้อมทรัพยากร Dependency ทั้งหมด

คลาส Repository และ DataSource ของโฟลว์จะมีลักษณะดังนี้

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 มีลักษณะอย่างไร

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

มีปัญหาเกิดขึ้นกับวิธีการนี้:

1. มีโค้ดสำเร็จรูปจำนวนมาก หากต้องการสร้างอินสแตนซ์อื่น ของ LoginViewModel ในส่วนอื่นของโค้ด การทำซ้ำโค้ดจะเป็นดังนี้

2. ต้องประกาศการขึ้นต่อกันตามลำดับ คุณต้องสร้างอินสแตนซ์ UserRepositoryก่อน LoginViewModel เพื่อสร้าง

3. นำออบเจ็กต์กลับมาใช้ใหม่ได้ยาก หากต้องการนำ UserRepository มาใช้ซ้ำ ในหลายฟีเจอร์ คุณต้องทำให้เป็นไปตาม singleton Pattern รูปแบบ Singleton ทำให้การทดสอบยากขึ้น เนื่องจากการทดสอบทั้งหมดจะ อินสแตนซ์เดี่ยวตัวเดียวกัน

การจัดการทรัพยากร Dependency ด้วยคอนเทนเนอร์

ในการแก้ปัญหาการใช้ออบเจ็กต์ซ้ำ คุณก็สร้างออบเจ็กต์ของคุณเองได้ คลาส dependencies Container ที่คุณใช้เพื่อรับทรัพยากร Dependency อินสแตนซ์ทั้งหมด ที่มาจากคอนเทนเนอร์นี้สามารถเป็นแบบสาธารณะได้ ในตัวอย่างนี้ เนื่องจากคุณต้อง อินสแตนซ์ของ UserRepository คุณสามารถทำให้ทรัพยากร Dependency ของอินสแตนซ์เป็นแบบส่วนตัวได้ด้วย ตัวเลือกในการเปลี่ยนเป็นแบบสาธารณะในอนาคตหากจำเป็น

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

เนื่องจากทรัพยากร Dependency เหล่านี้มีการใช้ทั่วทั้งแอปพลิเคชัน ระบบจึงต้อง ในตำแหน่งทั่วไปที่กิจกรรมทั้งหมดสามารถใช้ได้: Application สร้างแบบกำหนดเอง คลาส Application ที่มีอินสแตนซ์ AppContainer

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

ตอนนี้คุณสามารถรับอินสแตนซ์ของ AppContainer จากแอปพลิเคชันและ รับอินสแตนซ์ที่แชร์ของ UserRepository:

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

วิธีนี้ทำให้คุณไม่มี UserRepository แบบซิงเกิลตัน แต่คุณจะมี AppContainer แชร์ในทุกกิจกรรมที่มีออบเจ็กต์จากกราฟ และสร้างอินสแตนซ์ของออบเจ็กต์ ที่คลาสอื่นสามารถใช้ได้

หากจำเป็นต้องใช้ LoginViewModel ในที่อื่นๆ ในแอปพลิเคชัน ส่วนกลางที่คุณสร้างอินสแตนซ์ของ LoginViewModel ทำให้ ความรู้สึก คุณสามารถย้ายการสร้าง LoginViewModel ไปยังคอนเทนเนอร์และระบุ ใหม่ๆ ในประเภทนั้นด้วยโรงงาน รหัสสำหรับ LoginViewModelFactory ซึ่งมีลักษณะดังนี้

// 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 ไว้ใน AppContainer และทำการ LoginActivity ใช้:

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

วิธีการนี้ดีกว่าวิธีการก่อนหน้า แต่ก็ยังมี ความท้าทายที่ต้องพิจารณา:

1. คุณต้องจัดการ AppContainer ด้วยตนเอง โดยสร้างอินสแตนซ์ทั้งหมด ทรัพยากร Dependency เอง

2. ยังมีโค้ดแบบ Boilerplate อีกมาก คุณต้องสร้างโรงงานหรือ ด้วยตนเองโดยขึ้นอยู่กับว่าคุณต้องการนำออบเจ็กต์ไปใช้ซ้ำหรือไม่

การจัดการทรัพยากร Dependency ในขั้นตอนของแอปพลิเคชัน

AppContainer จะซับซ้อนขึ้นเรื่อยๆ เมื่อคุณต้องการเพิ่มฟังก์ชันการทํางานใน ให้กับโครงการ เมื่อแอปของคุณมีขนาดใหญ่ขึ้นและคุณเริ่มเปิดตัว ของฟีเจอร์ ก็ยังมีปัญหาเพิ่มเติมตามมาอีก เช่น

1. เมื่อคุณมีขั้นตอนที่แตกต่างกัน คุณอาจต้องการให้วัตถุอยู่แค่ใน ขอบเขตของขั้นตอนนั้น เช่น เมื่อสร้าง LoginUserData (อาจ ที่ประกอบด้วยชื่อผู้ใช้และรหัสผ่านที่ใช้ ในขั้นตอนการเข้าสู่ระบบเท่านั้น) ที่คุณไม่ต้องการ เพื่อเก็บข้อมูลจากขั้นตอนการเข้าสู่ระบบเดิมจากผู้ใช้รายอื่น คุณต้องการ สำหรับทุกขั้นตอนใหม่ ซึ่งทำได้โดยการสร้าง FlowContainer ภายใน AppContainer ดังที่แสดงในตัวอย่างโค้ดถัดไป

2. การเพิ่มประสิทธิภาพกราฟของแอปพลิเคชันและคอนเทนเนอร์โฟลว์ก็อาจเป็นเรื่องยากเช่นกัน คุณต้องจำว่าต้องลบอินสแตนซ์ที่ไม่ต้องการ โดยขึ้นอยู่กับ การใช้งานของคุณ

สมมติว่าคุณมีขั้นตอนการเข้าสู่ระบบที่ประกอบด้วยกิจกรรม 1 กิจกรรม (LoginActivity) และส่วนย่อยหลายรายการ (LoginUsernameFragment และ LoginPasswordFragment) มุมมองเหล่านี้ต้องการทำสิ่งต่อไปนี้

1. เข้าถึงอินสแตนซ์ LoginUserData เดียวกันที่จำเป็นต้องแชร์จนกว่า ดำเนินการตามขั้นตอนการเข้าสู่ระบบจนเสร็จสิ้น

2. สร้างอินสแตนซ์ใหม่ของ LoginUserData เมื่อโฟลว์เริ่มต้นอีกครั้ง

ซึ่งทำได้โดยใช้คอนเทนเนอร์ขั้นตอนการเข้าสู่ระบบ คอนเทนเนอร์นี้ต้องมีลักษณะดังนี้ สร้างขึ้นเมื่อขั้นตอนการเข้าสู่ระบบเริ่มต้นและนําออกจากหน่วยความจำเมื่อขั้นตอนดังกล่าวสิ้นสุด

มาเพิ่ม LoginContainer ลงในโค้ดตัวอย่างกัน คุณต้องการสร้าง LoginContainer หลายอินสแตนซ์ในแอป ดังนั้นแทนที่จะทำให้เป็น Singleton ทำให้เป็นคลาสที่มีทรัพยากร Dependency ที่โฟลว์การเข้าสู่ระบบต้องการ 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;
}

เมื่อมีคอนเทนเนอร์เฉพาะสำหรับขั้นตอนหนึ่งๆ แล้ว คุณก็ต้องตัดสินใจว่าจะสร้างเมื่อใด และลบอินสแตนซ์คอนเทนเนอร์ เนื่องจากขั้นตอนการเข้าสู่ระบบมีลักษณะในตัว กิจกรรม (LoginActivity) กิจกรรมคือสิ่งที่จัดการวงจร ของคอนเทนเนอร์นั้น LoginActivity สามารถสร้างอินสแตนซ์ใน onCreate() และ ลบทิ้งใน onDestroy()

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 ส่วนการเข้าสู่ระบบจะเข้าถึง LoginContainer จาก AppContainerและใช้อินสแตนซ์ LoginUserData ที่แชร์

เพราะในกรณีนี้คุณต้องจัดการกับตรรกะวงจรการดู โดยใช้ การสังเกตวงจรชีวิตก็สมเหตุสมผล

บทสรุป

การแทรกทรัพยากร Dependency เป็นเทคนิคที่ดีในการสร้างที่รองรับการปรับขนาดและทดสอบได้ แอป Android ใช้คอนเทนเนอร์เป็นวิธีแชร์อินสแตนซ์ของคลาสใน ส่วนหนึ่งของแอปของคุณ และเป็นศูนย์กลางในการสร้างอินสแตนซ์ โดยใช้โรงงาน

เมื่อแอปพลิเคชันของคุณมีขนาดใหญ่ขึ้น คุณจะเริ่มเห็นว่าคุณเขียน รหัส Boilerplate (เช่น โรงงาน) ซึ่งอาจเกิดข้อผิดพลาดได้ง่าย นอกจากนี้ คุณยังต้อง จัดการขอบเขตและวงจรของคอนเทนเนอร์ด้วยตนเอง รวมถึงเพิ่มประสิทธิภาพและ ทิ้งคอนเทนเนอร์ที่ไม่ต้องการแล้วเพื่อเพิ่มหน่วยความจำ การทำเช่นนี้ไม่ถูกต้องอาจทำให้เกิดข้อบกพร่องเล็กๆ น้อยๆ และทำให้หน่วยความจำรั่วไหลในแอป

ในส่วนกริช คุณจะ ดูวิธีใช้ Dagger เพื่อทำให้กระบวนการนี้เป็นไปโดยอัตโนมัติและสร้างโค้ดเดียวกัน ที่คุณเขียนด้วยมือเป็นอย่างอื่น