使用Dagger快速入门

荭色海湾

已于 2024-07-15 18:31:02 修改

阅读量838

点赞数 9

分类专栏： Dagger 文章标签： java 前端 html

于 2024-03-12 09:46:33 首次发布

本文链接：https://blog.youkuaiyun.com/qq_53374893/article/details/136633185

版权

Dagger 专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了Dagger2在Android应用中的依赖注入、组件、模块、作用域的使用，包括简单依赖注入、通过模块提供对象、单例模式、自定义作用域以及组件的全局绑定，帮助开发者理解和实现代理式依赖注入框架。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.导入依赖

   //dagger核心库
    implementation("com.google.dagger:dagger:2.30.1")
    //核心 适配器 编译器
    annotationProcessor("com.google.dagger:dagger-compiler:2.30.1")

2.简单依赖注入

package com.dagger.di;

import javax.inject.Inject;

public class User {

    //1.使用@Inject注解在构造方法上：就算告知Dagger可以通过构造方法来创建并获取到User实例
    @Inject
    public User() {
    }
}

package com.dagger.di;

import com.dagger.MainActivity;

import dagger.Component;

//相当于IOC容器 有一些对象的实例
@Component
public interface ApplicationComponent {


    //2.将对象注入到MainActivity这个类里
    void inject(MainActivity mainActivity);



}

package com.dagger;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.dagger.di.ApplicationComponent;
import com.dagger.di.DaggerApplicationComponent;
import com.dagger.di.User;

import javax.inject.Inject;

public class MainActivity extends AppCompatActivity {

    //3.加入对象
    @Inject
    User user;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //4.执行注入动作
        ApplicationComponent applicationComponent = DaggerApplicationComponent.create();
        applicationComponent.inject(this);


        System.out.println("user:"+user);


    }
}

3.第二种依赖注入

package com.dagger.di;

import javax.inject.Inject;

import dagger.Module;
import dagger.Provides;
import retrofit2.Retrofit;

//表明这个类是一个dagger模块
@Module
public class NetModule {


    //相当于Springboot @Bean  第二种方式告知Dagger 可以调用该方法来获取到要注入对象的实力
    @Provides
    public Retrofit provideRetrofit(){

        return new Retrofit.Builder()
                .baseUrl("https://www.baidu.com")
                .build();
    }
}

package com.dagger.di;

import com.dagger.MainActivity;

import dagger.Component;

//相当于IOC容器 有一些对象的实例
//把模块装载到这个组件上
@Component(modules = {NetModule.class})
public interface ApplicationComponent {


    //2.将对象注入到MainActivity这个类里
    void inject(MainActivity mainActivity);



}

package com.dagger;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.dagger.di.ApplicationComponent;
import com.dagger.di.DaggerApplicationComponent;
import com.dagger.di.User;

import javax.inject.Inject;

import retrofit2.Retrofit;

public class MainActivity extends AppCompatActivity {

    //3.加入对象
    @Inject
    User user;

    @Inject
    Retrofit retrofit;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //4.执行注入动作
        ApplicationComponent applicationComponent = DaggerApplicationComponent.create();
        applicationComponent.inject(this);


        System.out.println("user:"+user);
        System.out.println("re:"+retrofit);

    }
}

4.还可以通过参数注入向Springboot @Bean标注的方法参数会从容器中获取

 @Provides
    public ApiService provideApiService(Retrofit retrofit,User user){
        System.out.println("user in rongqi:"+user);
        //容器会自动找到 本容器里那个类里的对象
        return retrofit.create(ApiService.class);
    }

5.作用域实现单例模式

package com.dagger.di;

import android.util.Log;

import javax.inject.Inject;
import javax.inject.Singleton;

import dagger.Module;
import dagger.Provides;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;

//表明这个类是一个dagger模块
@Module
public class NetModule {
    @Singleton
    @Provides
    public OkHttpClient provideOkHttpClient(){

        return new OkHttpClient.Builder()
                .build();
    }


    //相当于Springboot @Bean  第二种方式告知Dagger 可以调用该方法来获取到要注入对象的实力
    @Singleton
    @Provides
    public Retrofit provideRetrofit(OkHttpClient okHttpClient){

        return new Retrofit.Builder()
                .client(okHttpClient)
                .baseUrl("https://www.baidu.com")
                .build();
    }

    @Singleton
    @Provides
    public ApiService provideApiService(Retrofit retrofit,User user){
        System.out.println("user in rongqi:"+user);
        //容器会自动找到 本容器里那个类里的对象
        return retrofit.create(ApiService.class);
    }




}

package com.dagger.di;

import com.dagger.MainActivity;

import javax.inject.Singleton;

import dagger.Component;

//相当于IOC容器 有一些对象的实例
//把模块装载到这个组件上
@Singleton
@Component(modules = {NetModule.class})
public interface ApplicationComponent {


    //2.将对象注入到MainActivity这个类里
    void inject(MainActivity mainActivity);



}

package com.dagger;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.dagger.di.ApiService;
import com.dagger.di.ApplicationComponent;
import com.dagger.di.DaggerApplicationComponent;
import com.dagger.di.User;

import java.sql.SQLOutput;

import javax.inject.Inject;

import retrofit2.Retrofit;

public class MainActivity extends AppCompatActivity {

    //3.加入对象
    @Inject
    User user;
    @Inject
    User user2;
    @Inject
    Retrofit retrofit;

    @Inject
    ApiService apiService;
    @Inject
    ApiService apiService2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //4.执行注入动作
        ApplicationComponent applicationComponent = DaggerApplicationComponent.create();
        applicationComponent.inject(this);


        System.out.println("user:"+user);
        System.out.println("re:"+retrofit);
        System.out.println("apiService:"+apiService);
        //true
        System.out.println(apiService==apiService2);
        //false
        System.out.println(user==user2);
    }
}

6.将组件生命周期绑定到全局

package com.dagger;

import android.app.Application;

import com.dagger.di.ApplicationComponent;
import com.dagger.di.DaggerApplicationComponent;

public class MyApplication extends Application {

  private static ApplicationComponent applicationComponent = DaggerApplicationComponent.create();

  public static ApplicationComponent getApplicationComponent(){
      return applicationComponent;
  }


    @Override
    public void onCreate() {
        super.onCreate();
    }
}

package com.dagger;



import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.dagger.di.ApiService;
import com.dagger.di.ApplicationComponent;
import com.dagger.di.DaggerApplicationComponent;
import com.dagger.di.User;

import java.sql.SQLOutput;

import javax.inject.Inject;

import retrofit2.Retrofit;

public class MainActivity extends AppCompatActivity {

    //3.加入对象
    @Inject
    User user;
    @Inject
    User user2;
    @Inject
    Retrofit retrofit;

    @Inject
    ApiService apiService;
    @Inject
    ApiService apiService2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //4.执行注入动作
        ApplicationComponent applicationComponent = MyApplication.getApplicationComponent();
        applicationComponent.inject(this);


        System.out.println("user:"+user);
        System.out.println("re:"+retrofit);
        System.out.println("apiService:"+apiService);
        //true
        System.out.println(apiService==apiService2);
        //false
        System.out.println(user==user2);
    }
}

7.作用域的规则

自定义作用域

其实就是声明了作用域的一个名字，把哪个对象的声明周期，绑定在了一个component上

package com.dagger.di;


import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;

import javax.inject.Scope;

@Scope
@Documented
@Retention(RUNTIME)
public @interface MyScope {
}

package com.dagger.di;
import com.dagger.MainActivity;

import javax.inject.Singleton;

import dagger.Component;

//相当于IOC容器 有一些对象的实例
//把模块装载到这个组件上
@MyScope
@Component(modules = {NetModule.class})
public interface ApplicationComponent {


    //2.将对象注入到MainActivity这个类里
    void inject(MainActivity mainActivity);



}

package com.dagger.di;

import android.util.Log;

import javax.inject.Inject;
import javax.inject.Singleton;

import dagger.Module;
import dagger.Provides;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;

//表明这个类是一个dagger模块
@Module
public class NetModule {
    @MyScope
    @Provides
    public OkHttpClient provideOkHttpClient(){

        return new OkHttpClient.Builder()
                .build();
    }


    //相当于Springboot @Bean  第二种方式告知Dagger 可以调用该方法来获取到要注入对象的实力
    @MyScope
    @Provides
    public Retrofit provideRetrofit(OkHttpClient okHttpClient){

        return new Retrofit.Builder()
                .client(okHttpClient)
                .baseUrl("https://www.baidu.com")
                .build();
    }

    @MyScope
    @Provides
    public ApiService provideApiService(Retrofit retrofit,User user){
        System.out.println("user in rongqi:"+user);
        //容器会自动找到 本容器里那个类里的对象
        return retrofit.create(ApiService.class);
    }




}