Android Dagger2 框架辅助工具模块深度剖析(六)

一、引言

在 Android 开发领域,依赖注入(Dependency Injection,简称 DI)作为一种至关重要的设计模式,能显著降低代码间的耦合度,提升代码的可测试性与可维护性。Dagger2 作为一款强大的依赖注入框架,凭借其在编译时生成依赖注入代码的特性,有效避免了运行时反射带来的性能损耗。而辅助工具模块在 Dagger2 中扮演着不可或缺的角色,它为开发者提供了一系列实用的工具和特性,助力开发者更高效地运用 Dagger2 进行开发。本文将全方位、深入地剖析 Dagger2 框架的辅助工具模块,从源码层面细致解读其实现原理与工作流程。

二、辅助工具模块概述

2.1 辅助工具模块的定义与作用

Dagger2 的辅助工具模块涵盖了一系列用于简化依赖注入过程、增强代码灵活性和可维护性的工具和特性。这些工具和特性并非直接参与依赖注入的核心流程,而是在开发过程中提供辅助支持,例如提供更便捷的依赖绑定方式、实现依赖替换、进行多绑定等。

2.2 辅助工具模块的主要组成部分

  • 多绑定(Multibindings) :允许将多个依赖对象绑定到同一个类型上,实现依赖对象的集合注入。
  • 限定符(Qualifiers) :为依赖对象添加额外的标识,在注入时可区分不同的依赖对象。
  • 依赖替换(Dependency Substitution) :在测试环境中能够替换生产环境中的依赖对象,便于进行单元测试。
  • 子组件(Subcomponents) :用于管理更细粒度的依赖关系,可继承父组件的依赖并定义自身的依赖和作用域。

三、多绑定(Multibindings)

3.1 多绑定的概念与用途

多绑定是 Dagger2 提供的一种强大特性,它允许将多个依赖对象绑定到同一个类型上。通过多绑定,开发者可以实现依赖对象的集合注入,这在需要处理多个相同类型依赖对象的场景中非常实用,例如插件系统、事件监听器集合等。

3.2 多绑定的类型

Dagger2 支持三种类型的多绑定:

  • Set 绑定(Set Bindings) :将多个依赖对象绑定到一个 Set 集合中。
  • Map 绑定(Map Bindings) :将多个依赖对象绑定到一个 Map 中,每个对象对应一个键。
  • IntoSet 和 IntoMap 注解:用于将单个依赖对象添加到 Set 或 Map 中。

3.3 Set 绑定的源码分析

3.3.1 Set 绑定的使用示例

java

import dagger.Module;
import dagger.Provides;
import dagger.multibindings.IntoSet;
import java.util.Set;
import javax.inject.Inject;// 定义一个依赖类
class Service {public void performService() {System.out.println("Performing service");}
}// 使用 @Module 注解标记模块类
@Module
class ServiceModule {// 使用 @IntoSet 注解将 Service 类的实例添加到集合中@Provides@IntoSetpublic Service provideService1() {return new Service();}// 使用 @IntoSet 注解将另一个 Service 类的实例添加到集合中@Provides@IntoSetpublic Service provideService2() {return new Service();}
}// 定义一个需要注入集合的类
class ServiceManager {private final Set<Service> services;// 使用 @Inject 注解标记构造函数@Injectpublic ServiceManager(Set<Service> services) {this.services = services;}public void startServices() {for (Service service : services) {service.performService();}}
}// 定义组件接口
import dagger.Component;@Component(modules = ServiceModule.class)
interface ServiceComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(ServiceManager manager);
}public class SetBindingExample {public static void main(String[] args) {// 创建组件实例ServiceComponent serviceComponent = DaggerServiceComponent.create();// 创建目标对象实例ServiceManager serviceManager = new ServiceManager(null);// 使用组件实例将依赖对象注入到目标对象中serviceComponent.inject(serviceManager);// 调用目标对象的方法serviceManager.startServices();}
}
3.3.2 Set 绑定的源码实现

在编译时,Dagger2 的注解处理器会根据 @IntoSet 注解生成相应的代码。以下是简化后的生成代码示例,用于说明 Set 绑定的实现原理:

java

// 生成的组件实现类
public final class DaggerServiceComponent implements ServiceComponent {private final ServiceModule serviceModule;private final java.util.Set<Service> serviceSet;private DaggerServiceComponent(ServiceModule serviceModule) {this.serviceModule = serviceModule;// 创建一个可变的 Set 集合java.util.Set<Service> mutableSet = new java.util.LinkedHashSet<>();// 添加第一个 Service 实例mutableSet.add(serviceModule.provideService1());// 添加第二个 Service 实例mutableSet.add(serviceModule.provideService2());// 将可变集合转换为不可变集合this.serviceSet = java.util.Collections.unmodifiableSet(mutableSet);}public static ServiceComponent create() {return new DaggerServiceComponent(new ServiceModule());}@Overridepublic void inject(ServiceManager manager) {// 将 Set 集合注入到目标对象中new ServiceManager(serviceSet);}
}

从上述代码可以看出,Dagger2 在生成的组件实现类中创建了一个 Set 集合,并将所有使用 @IntoSet 注解提供的依赖对象添加到该集合中。最后,将该集合注入到需要的目标对象中。

3.4 Map 绑定的源码分析

3.4.1 Map 绑定的使用示例

java

import dagger.Module;
import dagger.Provides;
import dagger.multibindings.IntoMap;
import dagger.multibindings.StringKey;
import java.util.Map;
import javax.inject.Inject;// 定义一个依赖类
class Processor {public void process() {System.out.println("Processing");}
}// 使用 @Module 注解标记模块类
@Module
class ProcessorModule {// 使用 @IntoMap 注解将 Processor 类的实例添加到 Map 中,并使用 @StringKey 指定键@Provides@IntoMap@StringKey("processor1")public Processor provideProcessor1() {return new Processor();}// 使用 @IntoMap 注解将另一个 Processor 类的实例添加到 Map 中,并使用 @StringKey 指定键@Provides@IntoMap@StringKey("processor2")public Processor provideProcessor2() {return new Processor();}
}// 定义一个需要注入 Map 的类
class ProcessorManager {private final Map<String, Processor> processors;// 使用 @Inject 注解标记构造函数@Injectpublic ProcessorManager(Map<String, Processor> processors) {this.processors = processors;}public void processAll() {for (Map.Entry<String, Processor> entry : processors.entrySet()) {System.out.println("Processing with " + entry.getKey());entry.getValue().process();}}
}// 定义组件接口
import dagger.Component;@Component(modules = ProcessorModule.class)
interface ProcessorComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(ProcessorManager manager);
}public class MapBindingExample {public static void main(String[] args) {// 创建组件实例ProcessorComponent processorComponent = DaggerProcessorComponent.create();// 创建目标对象实例ProcessorManager processorManager = new ProcessorManager(null);// 使用组件实例将依赖对象注入到目标对象中processorComponent.inject(processorManager);// 调用目标对象的方法processorManager.processAll();}
}
3.4.2 Map 绑定的源码实现

在编译时,Dagger2 的注解处理器会根据 @IntoMap 和 @StringKey 注解生成相应的代码。以下是简化后的生成代码示例,用于说明 Map 绑定的实现原理:

java

// 生成的组件实现类
public final class DaggerProcessorComponent implements ProcessorComponent {private final ProcessorModule processorModule;private final java.util.Map<String, Processor> processorMap;private DaggerProcessorComponent(ProcessorModule processorModule) {this.processorModule = processorModule;// 创建一个可变的 Mapjava.util.Map<String, Processor> mutableMap = new java.util.LinkedHashMap<>();// 添加第一个 Processor 实例,并使用指定的键mutableMap.put("processor1", processorModule.provideProcessor1());// 添加第二个 Processor 实例,并使用指定的键mutableMap.put("processor2", processorModule.provideProcessor2());// 将可变 Map 转换为不可变 Mapthis.processorMap = java.util.Collections.unmodifiableMap(mutableMap);}public static ProcessorComponent create() {return new DaggerProcessorComponent(new ProcessorModule());}@Overridepublic void inject(ProcessorManager manager) {// 将 Map 注入到目标对象中new ProcessorManager(processorMap);}
}

从上述代码可以看出,Dagger2 在生成的组件实现类中创建了一个 Map,并将所有使用 @IntoMap 注解提供的依赖对象添加到该 Map 中,同时使用 @StringKey 指定的键作为 Map 的键。最后,将该 Map 注入到需要的目标对象中。

四、限定符(Qualifiers)

4.1 限定符的概念与用途

限定符是 Dagger2 提供的一种机制,用于为依赖对象添加额外的标识。当存在多个相同类型的依赖对象时,通过使用限定符,开发者可以在注入时区分不同的依赖对象,确保注入正确的依赖。

4.2 限定符的定义与使用

4.2.1 定义限定符注解

java

import javax.inject.Qualifier;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;// 定义一个限定符注解
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface PrimaryEngine {}// 定义另一个限定符注解
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface SecondaryEngine {}
4.2.2 使用限定符注解

java

import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;// 定义一个依赖类
class Engine {public void start() {System.out.println("Engine started");}
}// 使用 @Module 注解标记模块类
@Module
class CarModule {// 使用 @PrimaryEngine 限定符注解标记提供依赖对象的方法@Provides@PrimaryEnginepublic Engine providePrimaryEngine() {return new Engine();}// 使用 @SecondaryEngine 限定符注解标记提供依赖对象的方法@Provides@SecondaryEnginepublic Engine provideSecondaryEngine() {return new Engine();}
}// 定义一个需要注入依赖的类
class Car {private final Engine primaryEngine;private final Engine secondaryEngine;// 使用 @Inject 注解标记构造函数,并使用限定符注解区分不同的依赖对象@Injectpublic Car(@PrimaryEngine Engine primaryEngine, @SecondaryEngine Engine secondaryEngine) {this.primaryEngine = primaryEngine;this.secondaryEngine = secondaryEngine;}public void startPrimaryEngine() {primaryEngine.start();}public void startSecondaryEngine() {secondaryEngine.start();}
}// 定义组件接口
@Component(modules = CarModule.class)
interface CarComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(Car car);
}public class QualifierExample {public static void main(String[] args) {// 创建组件实例CarComponent carComponent = DaggerCarComponent.create();// 创建目标对象实例Car car = new Car(null, null);// 使用组件实例将依赖对象注入到目标对象中carComponent.inject(car);// 调用目标对象的方法car.startPrimaryEngine();car.startSecondaryEngine();}
}

4.3 限定符的源码分析

在编译时,Dagger2 的注解处理器会识别限定符注解,并在生成的代码中使用这些限定符来区分不同的依赖对象。以下是简化后的生成代码示例,用于说明限定符的实现原理:

java

// 生成的组件实现类
public final class DaggerCarComponent implements CarComponent {private final CarModule carModule;private DaggerCarComponent(CarModule carModule) {this.carModule = carModule;}public static CarComponent create() {return new DaggerCarComponent(new CarModule());}@Overridepublic void inject(Car car) {// 根据 @PrimaryEngine 限定符获取对应的 Engine 实例Engine primaryEngine = carModule.providePrimaryEngine();// 根据 @SecondaryEngine 限定符获取对应的 Engine 实例Engine secondaryEngine = carModule.provideSecondaryEngine();// 将依赖对象注入到目标对象中new Car(primaryEngine, secondaryEngine);}
}

从上述代码可以看出,Dagger2 在生成的组件实现类中,根据限定符注解调用相应的提供依赖对象的方法,确保注入正确的依赖对象。

五、依赖替换(Dependency Substitution)

5.1 依赖替换的概念与用途

依赖替换允许开发者在测试环境中替换生产环境中的依赖对象,从而方便进行单元测试。通过依赖替换,开发者可以模拟不同的依赖对象行为,验证代码在不同情况下的正确性。

5.2 依赖替换的实现方式

5.2.1 使用不同的模块

在测试环境中,可以创建一个专门的测试模块,该模块提供与生产环境不同的依赖对象。通过在组件中使用测试模块替换生产模块,实现依赖对象的替换。

java

import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;// 生产环境的依赖类
class ProductionDependency {public void doSomething() {System.out.println("Production dependency doing something");}
}// 测试环境的依赖类
class TestDependency {public void doSomething() {System.out.println("Test dependency doing something");}
}// 生产环境的模块
@Module
class ProductionModule {@ProvidesProductionDependency provideProductionDependency() {return new ProductionDependency();}
}// 测试环境的模块
@Module
class TestModule {@ProvidesTestDependency provideTestDependency() {return new TestDependency();}
}// 组件
@Component(modules = ProductionModule.class)
interface MyComponent {void inject(MyClass myClass);
}// 需要注入依赖的类
class MyClass {@InjectProductionDependency dependency;public void performAction() {dependency.doSomething();}
}// 测试类
public class DependencySubstitutionTest {public static void main(String[] args) {// 生产环境的组件实例MyComponent productionComponent = DaggerMyComponent.create();MyClass productionMyClass = new MyClass();productionComponent.inject(productionMyClass);productionMyClass.performAction();// 测试环境的组件实例(假设通过某种方式替换了模块)// 这里只是示例,实际中可能需要更复杂的配置// 例如使用 Dagger 的 builder 模式来替换模块// 这里简单模拟TestModule testModule = new TestModule();// 假设存在一个 TestComponent 继承自 MyComponent 并使用 TestModule// TestComponent testComponent = DaggerTestComponent.builder().testModule(testModule).build();// MyClass testMyClass = new MyClass();// testComponent.inject(testMyClass);// testMyClass.performAction();}
}
5.2.2 源码分析

在编译时,Dagger2 会根据组件所使用的模块来生成相应的代码。当使用不同的模块时,生成的代码会调用不同模块中提供依赖对象的方法,从而实现依赖对象的替换。以下是简化后的生成代码示例,用于说明依赖替换的实现原理:

java

// 生产环境的组件实现类
public final class DaggerMyComponent implements MyComponent {private final ProductionModule productionModule;private DaggerMyComponent(ProductionModule productionModule) {this.productionModule = productionModule;}public static MyComponent create() {return new DaggerMyComponent(new ProductionModule());}@Overridepublic void inject(MyClass myClass) {// 从生产模块中获取依赖对象ProductionDependency dependency = productionModule.provideProductionDependency();// 将依赖对象注入到目标对象中myClass.dependency = dependency;}
}// 假设的测试环境的组件实现类
public final class DaggerTestComponent implements MyComponent {private final TestModule testModule;private DaggerTestComponent(TestModule testModule) {this.testModule = testModule;}public static MyComponent create() {return new DaggerTestComponent(new TestModule());}@Overridepublic void inject(MyClass myClass) {// 从测试模块中获取依赖对象TestDependency dependency = testModule.provideTestDependency();// 将依赖对象注入到目标对象中myClass.dependency = (ProductionDependency) dependency; // 这里只是示例,实际需要类型兼容}
}

从上述代码可以看出,生产环境的组件实现类从生产模块中获取依赖对象,而测试环境的组件实现类从测试模块中获取依赖对象,从而实现了依赖对象的替换。

六、子组件(Subcomponents)

6.1 子组件的概念与用途

子组件是 Dagger2 中用于管理更细粒度依赖关系的一种机制。子组件可以继承父组件的依赖,并且可以定义自己的依赖和作用域。通过使用子组件,开发者可以将依赖关系进行分层管理,提高代码的可维护性和灵活性。

6.2 子组件的定义与使用

6.2.1 定义父组件和子组件

java

import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;
import dagger.Subcomponent;// 父组件的模块
@Module
class ParentModule {@ProvidesString provideParentString() {return "Parent String";}
}// 父组件
@Component(modules = ParentModule.class)
interface ParentComponent {ChildComponent.Builder childComponentBuilder();
}// 子组件的模块
@Module
class ChildModule {@ProvidesString provideChildString() {return "Child String";}
}// 子组件
@Subcomponent(modules = ChildModule.class)
interface ChildComponent {void inject(Child child);@Subcomponent.Builderinterface Builder {ChildComponent build();Builder childModule(ChildModule module);}
}// 子组件注入的目标类
class Child {@InjectString parentString;@InjectString childString;public void printStrings() {System.out.println(parentString);System.out.println(childString);}
}public class SubcomponentExample {public static void main(String[] args) {// 创建父组件实例ParentComponent parentComponent = DaggerParentComponent.create();// 创建子组件实例ChildComponent childComponent = parentComponent.childComponentBuilder().childModule(new ChildModule()).build();// 创建目标对象实例Child child = new Child();// 使用子组件实例将依赖对象注入到目标对象中childComponent.inject(child);// 调用目标对象的方法child.printStrings();}
}
6.2.2 子组件的源码分析

在编译时,Dagger2 会为子组件生成相应的代码。子组件可以访问父组件的依赖,因为子组件的生成代码会持有父组件的引用。以下是简化后的生成代码示例,用于说明子组件的实现原理:

java

// 生成的父组件实现类
public final class DaggerParentComponent implements ParentComponent {private static final class ParentScopeHolder {private static final DaggerParentComponent INSTANCE = new DaggerParentComponent();}private final String parentString;private DaggerParentComponent() {parentString = new ParentModule().provideParentString();}public static ParentComponent create() {return ParentScopeHolder.INSTANCE;}@Overridepublic ChildComponent.Builder childComponentBuilder() {return new ChildComponentBuilder();}private final class ChildComponentBuilder implements ChildComponent.Builder {private ChildModule childModule;@Overridepublic ChildComponent build() {if (childModule == null) {throw new IllegalStateException("ChildModule must be set");}return new DaggerChildComponent(DaggerParentComponent.this, childModule);}@Overridepublic Builder childModule(ChildModule module) {this.childModule = module;return this;}}
}// 生成的子组件实现类
public final class DaggerChildComponent implements ChildComponent {private final DaggerParentComponent parentComponent;private final ChildModule childModule;private final String childString;private DaggerChildComponent(DaggerParentComponent parentComponent, ChildModule childModule) {this.parentComponent = parentComponent;this.childModule = childModule;this.childString = childModule.provideChildString();}@Overridepublic void inject(Child child) {// 从父组件获取依赖child.parentString = parentComponent.parentString;// 从子组件的模块获取依赖child.childString = childString;}
}

从上述代码可以看出,父组件 DaggerParentComponent 持有 parentString 依赖对象,子组件 DaggerChildComponent 持有父组件的引用,并可以从父组件中获取依赖对象。同时,子组件还可以从自己的模块中获取依赖对象,实现了依赖关系的分层管理。

七、辅助工具模块的性能优化

7.1 减少不必要的多绑定和限定符使用

过多的多绑定和限定符会增加代码的复杂度和编译时间。在使用多绑定和限定符时,应确保确实有必要,避免不必要的使用。例如,如果只需要一个依赖对象,就不需要使用多绑定;如果不存在多个相同类型的依赖对象,就不需要使用限定符。

7.2 优化子组件的使用

子组件的使用可以提高代码的可维护性,但过多的子组件会增加代码的复杂度和内存开销。在使用子组件时,应合理规划子组件的层次结构,避免创建过多的子组件。同时,应确保子组件的作用域合理,避免作用域冲突和内存泄漏。

7.3 利用编译时优化

Dagger2 在编译时生成依赖注入代码,利用编译时优化可以提高性能。可以通过以下方式利用编译时优化:

  • 减少反射使用:Dagger2 避免了运行时反射,应尽量避免在代码中手动使用反射。
  • 使用代码生成工具:Dagger2 的注解处理器会生成高效的依赖注入代码,应充分利用这些生成的代码。

八、辅助工具模块的调试和错误处理

8.1 调试技巧

在使用 Dagger2 的辅助工具模块时,可能会遇到一些问题,以下是一些调试技巧:

  • 查看生成的代码:Dagger2 在编译时会生成大量的代码,可以查看这些生成的代码来了解依赖注入的具体实现。
  • 使用日志输出:在关键的地方添加日志输出,查看依赖对象的创建和注入过程。
  • 使用调试工具:可以使用 Android Studio 等开发工具的调试功能,逐步调试依赖注入的过程。

8.2 常见错误及解决方法

8.2.1 多绑定冲突错误

当多个模块提供相同类型的依赖对象并使用多绑定注解时,可能会导致多绑定冲突错误。解决方法如下:

  • 检查多绑定注解的使用:确保多绑定注解使用正确,避免重复绑定相同类型的依赖对象。
  • 使用限定符区分:如果需要绑定多个相同类型的依赖对象,可以使用限定符来区分它们。
8.2.2 限定符不匹配错误

当注入时使用的限定符与提供依赖对象时使用的限定符不匹配时,会导致限定符不匹配错误。解决方法如下:

  • 检查限定符注解的使用:确保注入和提供依赖对象时使用的限定符注解一致。
  • 检查组件和模块的配置:确保组件和模块中正确配置了限定符。
8.2.3 子组件作用域冲突错误

当子组件的作用域与父组件的作用域冲突时,会导致编译错误。解决方法如下:

  • 检查作用域注解的使用:确保子组件和父组件的作用域注解使用正确,避免作用域冲突。
  • 调整子组件和父组件的作用域:根据实际需求,调整子组件和父组件的作用域。

九、辅助工具模块在 Android 开发中的应用

9.1 在 Activity 和 Fragment 中的应用

在 Android 开发中,Activity 和 Fragment 有自己的生命周期。可以使用子组件和限定符来管理与 Activity 或 Fragment 相关的依赖对象,确保这些依赖

继续分析

9.1 在 Activity 和 Fragment 中的应用(续)

9.1.1 子组件在 Activity 中的使用

在 Android 应用里,Activity 有着自身独特的生命周期。借助子组件,我们能够精准管理与 Activity 相关的依赖对象,保证这些依赖对象的生命周期和 Activity 保持一致。

以下是一个在 Activity 中运用子组件的示例:

java

import android.app.Activity;
import android.os.Bundle;
import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;
import dagger.Subcomponent;// 定义一个依赖类
class ActivityDependency {public void doActivityWork() {System.out.println("Doing activity work");}
}// 父组件的模块
@Module
class AppModule {// 提供一个通用的依赖对象@ProvidesString provideAppString() {return "App String";}
}// 父组件
@Component(modules = AppModule.class)
interface AppComponent {// 定义创建子组件的方法ActivityComponent.Builder activityComponentBuilder();
}// 子组件的模块
@Module
class ActivityModule {private final Activity activity;public ActivityModule(Activity activity) {this.activity = activity;}// 提供与 Activity 相关的依赖对象@ProvidesActivityDependency provideActivityDependency() {return new ActivityDependency();}
}// 子组件
@Subcomponent(modules = ActivityModule.class)
interface ActivityComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(MainActivity activity);@Subcomponent.Builderinterface Builder {ActivityComponent build();Builder activityModule(ActivityModule module);}
}// 主 Activity 类
public class MainActivity extends Activity {// 使用 @Inject 注解标记需要注入的字段@InjectActivityDependency activityDependency;@InjectString appString;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 获取父组件实例AppComponent appComponent = ((MyApplication) getApplication()).getAppComponent();// 创建子组件实例ActivityComponent activityComponent = appComponent.activityComponentBuilder().activityModule(new ActivityModule(this)).build();// 使用子组件实例将依赖对象注入到目标对象中activityComponent.inject(this);// 调用依赖对象的方法activityDependency.doActivityWork();System.out.println(appString);}
}// 自定义 Application 类
class MyApplication extends android.app.Application {private AppComponent appComponent;@Overridepublic void onCreate() {super.onCreate();appComponent = DaggerAppComponent.create();}public AppComponent getAppComponent() {return appComponent;}
}
源码分析
  • 父组件 DaggerAppComponent

java

public final class DaggerAppComponent implements AppComponent {private static final class AppScopeHolder {private static final DaggerAppComponent INSTANCE = new DaggerAppComponent();}private final String appString;private DaggerAppComponent() {appString = new AppModule().provideAppString();}public static AppComponent create() {return AppScopeHolder.INSTANCE;}@Overridepublic ActivityComponent.Builder activityComponentBuilder() {return new ActivityComponentBuilder();}private final class ActivityComponentBuilder implements ActivityComponent.Builder {private ActivityModule activityModule;@Overridepublic ActivityComponent build() {if (activityModule == null) {throw new IllegalStateException("ActivityModule must be set");}return new DaggerActivityComponent(DaggerAppComponent.this, activityModule);}@Overridepublic Builder activityModule(ActivityModule module) {this.activityModule = module;return this;}}
}

父组件负责创建通用的依赖对象(如 appString),并且提供创建子组件的方法。子组件的构建器会持有父组件的引用,以便子组件能够访问父组件的依赖。

  • 子组件 DaggerActivityComponent

java

public final class DaggerActivityComponent implements ActivityComponent {private final DaggerAppComponent parentComponent;private final ActivityModule activityModule;private final ActivityDependency activityDependency;private DaggerActivityComponent(DaggerAppComponent parentComponent, ActivityModule activityModule) {this.parentComponent = parentComponent;this.activityModule = activityModule;this.activityDependency = activityModule.provideActivityDependency();}@Overridepublic void inject(MainActivity activity) {activity.activityDependency = activityDependency;activity.appString = parentComponent.appString;}
}

子组件持有父组件的引用,能够获取父组件的依赖(如 appString),同时从自身的模块中获取与 Activity 相关的依赖(如 activityDependency),并将这些依赖注入到目标 Activity 中。

9.1.2 限定符在 Fragment 中的使用

在 Fragment 中,有时会存在多个相同类型的依赖对象,此时可以使用限定符来区分它们。

以下是一个在 Fragment 中使用限定符的示例:

java

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.fragment.app.Fragment;
import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;
import dagger.multibindings.IntoSet;
import java.util.Set;// 定义一个依赖类
class FragmentDependency {public void doFragmentWork() {System.out.println("Doing fragment work");}
}// 定义限定符注解
import javax.inject.Qualifier;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface PrimaryDependency {}@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface SecondaryDependency {}// 模块类
@Module
class FragmentModule {// 提供主依赖对象@Provides@PrimaryDependencypublic FragmentDependency providePrimaryDependency() {return new FragmentDependency();}// 提供次依赖对象@Provides@SecondaryDependencypublic FragmentDependency provideSecondaryDependency() {return new FragmentDependency();}
}// 组件接口
@Component(modules = FragmentModule.class)
interface FragmentComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(MyFragment fragment);
}// 自定义 Fragment 类
public class MyFragment extends Fragment {// 使用 @Inject 注解标记需要注入的字段@Inject@PrimaryDependencyFragmentDependency primaryDependency;@Inject@SecondaryDependencyFragmentDependency secondaryDependency;@Overridepublic View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {// 获取组件实例FragmentComponent fragmentComponent = DaggerFragmentComponent.create();// 使用组件实例将依赖对象注入到目标对象中fragmentComponent.inject(this);// 调用依赖对象的方法primaryDependency.doFragmentWork();secondaryDependency.doFragmentWork();return inflater.inflate(R.layout.fragment_my, container, false);}
}
源码分析
  • 组件 DaggerFragmentComponent

java

public final class DaggerFragmentComponent implements FragmentComponent {private final FragmentModule fragmentModule;private DaggerFragmentComponent(FragmentModule fragmentModule) {this.fragmentModule = fragmentModule;}public static FragmentComponent create() {return new DaggerFragmentComponent(new FragmentModule());}@Overridepublic void inject(MyFragment fragment) {// 根据限定符获取对应的依赖对象FragmentDependency primaryDependency = fragmentModule.providePrimaryDependency();FragmentDependency secondaryDependency = fragmentModule.provideSecondaryDependency();fragment.primaryDependency = primaryDependency;fragment.secondaryDependency = secondaryDependency;}
}

在组件的注入方法中,根据限定符调用相应的提供依赖对象的方法,确保将正确的依赖对象注入到 Fragment 中。

9.2 在 Service 中的应用

在 Android 开发里,Service 是一种在后台运行的组件,具备自身的生命周期。可以运用子组件和限定符来管理与 Service 相关的依赖对象,保证这些依赖对象的生命周期和 Service 一致。

以下是一个在 Service 中使用子组件和限定符的示例:

java

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;
import dagger.Subcomponent;// 定义一个依赖类
class ServiceDependency {public void doServiceWork() {System.out.println("Doing service work");}
}// 父组件的模块
@Module
class AppModule {// 提供一个通用的依赖对象@ProvidesString provideAppString() {return "App String";}
}// 父组件
@Component(modules = AppModule.class)
interface AppComponent {// 定义创建子组件的方法ServiceComponent.Builder serviceComponentBuilder();
}// 定义限定符注解
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface ServiceSpecificDependency {}// 子组件的模块
@Module
class ServiceModule {private final Service service;public ServiceModule(Service service) {this.service = service;}// 提供与 Service 相关的依赖对象@Provides@ServiceSpecificDependencyServiceDependency provideServiceDependency() {return new ServiceDependency();}
}// 子组件
@Subcomponent(modules = ServiceModule.class)
interface ServiceComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(MyService service);@Subcomponent.Builderinterface Builder {ServiceComponent build();Builder serviceModule(ServiceModule module);}
}// 自定义 Service 类
public class MyService extends Service {// 使用 @Inject 注解标记需要注入的字段@Inject@ServiceSpecificDependencyServiceDependency serviceDependency;@InjectString appString;@Overridepublic void onCreate() {super.onCreate();// 获取父组件实例AppComponent appComponent = ((MyApplication) getApplication()).getAppComponent();// 创建子组件实例ServiceComponent serviceComponent = appComponent.serviceComponentBuilder().serviceModule(new ServiceModule(this)).build();// 使用子组件实例将依赖对象注入到目标对象中serviceComponent.inject(this);// 调用依赖对象的方法serviceDependency.doServiceWork();System.out.println(appString);}@Overridepublic IBinder onBind(Intent intent) {return null;}
}// 自定义 Application 类
class MyApplication extends android.app.Application {private AppComponent appComponent;@Overridepublic void onCreate() {super.onCreate();appComponent = DaggerAppComponent.create();}public AppComponent getAppComponent() {return appComponent;}
}
源码分析
  • 父组件 DaggerAppComponent:和 Activity 中的父组件类似,负责创建通用的依赖对象(如 appString),并提供创建子组件的方法。

  • 子组件 DaggerServiceComponent

java

public final class DaggerServiceComponent implements ServiceComponent {private final DaggerAppComponent parentComponent;private final ServiceModule serviceModule;private final ServiceDependency serviceDependency;private DaggerServiceComponent(DaggerAppComponent parentComponent, ServiceModule serviceModule) {this.parentComponent = parentComponent;this.serviceModule = serviceModule;this.serviceDependency = serviceModule.provideServiceDependency();}@Overridepublic void inject(MyService service) {service.serviceDependency = serviceDependency;service.appString = parentComponent.appString;}
}

子组件持有父组件的引用,能够获取父组件的依赖(如 appString),同时从自身的模块中获取与 Service 相关的依赖(如 serviceDependency),并将这些依赖注入到目标 Service 中。

9.3 在 Repository 模式中的应用

在 Android 开发的 MVVM、MVP 等架构模式里,Repository 模式常用于管理数据的获取和存储。Dagger2 的辅助工具模块能够助力管理 Repository 相关的依赖对象。

9.3.1 多绑定在 Repository 中的使用

假设我们有多种数据来源(如网络、本地数据库),可以使用多绑定将这些数据来源的 Repository 绑定到一个集合中。

以下是一个使用多绑定的 Repository 示例:

java

import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;
import dagger.multibindings.IntoSet;
import java.util.Set;// 定义一个 Repository 接口
interface DataRepository {void fetchData();
}// 网络数据 Repository 实现类
class NetworkDataRepository implements DataRepository {@Overridepublic void fetchData() {System.out.println("Fetching data from network");}
}// 本地数据 Repository 实现类
class LocalDataRepository implements DataRepository {@Overridepublic void fetchData() {System.out.println("Fetching data from local");}
}// 模块类
@Module
class RepositoryModule {// 将网络数据 Repository 添加到集合中@Provides@IntoSetpublic DataRepository provideNetworkDataRepository() {return new NetworkDataRepository();}// 将本地数据 Repository 添加到集合中@Provides@IntoSetpublic DataRepository provideLocalDataRepository() {return new LocalDataRepository();}
}// 组件接口
@Component(modules = RepositoryModule.class)
interface RepositoryComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(DataManager manager);
}// 数据管理类
class DataManager {private final Set<DataRepository> dataRepositories;@Injectpublic DataManager(Set<DataRepository> dataRepositories) {this.dataRepositories = dataRepositories;}public void fetchAllData() {for (DataRepository repository : dataRepositories) {repository.fetchData();}}
}public class RepositoryExample {public static void main(String[] args) {// 创建组件实例RepositoryComponent repositoryComponent = DaggerRepositoryComponent.create();// 创建目标对象实例DataManager dataManager = new DataManager(null);// 使用组件实例将依赖对象注入到目标对象中repositoryComponent.inject(dataManager);// 调用目标对象的方法dataManager.fetchAllData();}
}
源码分析
  • 组件 DaggerRepositoryComponent

java

public final class DaggerRepositoryComponent implements RepositoryComponent {private final RepositoryModule repositoryModule;private final java.util.Set<DataRepository> dataRepositorySet;private DaggerRepositoryComponent(RepositoryModule repositoryModule) {this.repositoryModule = repositoryModule;// 创建一个可变的 Set 集合java.util.Set<DataRepository> mutableSet = new java.util.LinkedHashSet<>();// 添加网络数据 RepositorymutableSet.add(repositoryModule.provideNetworkDataRepository());// 添加本地数据 RepositorymutableSet.add(repositoryModule.provideLocalDataRepository());// 将可变集合转换为不可变集合this.dataRepositorySet = java.util.Collections.unmodifiableSet(mutableSet);}public static RepositoryComponent create() {return new DaggerRepositoryComponent(new RepositoryModule());}@Overridepublic void inject(DataManager manager) {// 将 Set 集合注入到目标对象中new DataManager(dataRepositorySet);}
}

在组件的构造函数中,创建一个 Set 集合,并将所有使用 @IntoSet 注解提供的 DataRepository 实例添加到该集合中,最后将集合注入到 DataManager 中。

9.3.2 限定符在 Repository 中的使用

当存在多个不同类型的 Repository 时,可以使用限定符来区分它们。

以下是一个使用限定符的 Repository 示例:

java

import javax.inject.Inject;
import dagger.Module;
import dagger.Provides;
import dagger.Component;// 定义一个 Repository 接口
interface UserRepository {void getUserData();
}// 定义限定符注解
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface RemoteUserRepository {}@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@interface LocalUserRepository {}// 远程用户数据 Repository 实现类
class RemoteUserDataRepository implements UserRepository {@Overridepublic void getUserData() {System.out.println("Getting user data from remote");}
}// 本地用户数据 Repository 实现类
class LocalUserDataRepository implements UserRepository {@Overridepublic void getUserData() {System.out.println("Getting user data from local");}
}// 模块类
@Module
class UserRepositoryModule {// 提供远程用户数据 Repository@Provides@RemoteUserRepositorypublic UserRepository provideRemoteUserRepository() {return new RemoteUserDataRepository();}// 提供本地用户数据 Repository@Provides@LocalUserRepositorypublic UserRepository provideLocalUserRepository() {return new LocalUserDataRepository();}
}// 组件接口
@Component(modules = UserRepositoryModule.class)
interface UserRepositoryComponent {// 定义注入方法,用于将依赖对象注入到目标对象中void inject(UserDataManager manager);
}// 用户数据管理类
class UserDataManager {private final UserRepository remoteUserRepository;private final UserRepository localUserRepository;@Injectpublic UserDataManager(@RemoteUserRepository UserRepository remoteUserRepository,@LocalUserRepository UserRepository localUserRepository) {this.remoteUserRepository = remoteUserRepository;this.localUserRepository = localUserRepository;}public void fetchAllUserData() {remoteUserRepository.getUserData();localUserRepository.getUserData();}
}public class UserRepositoryExample {public static void main(String[] args) {// 创建组件实例UserRepositoryComponent userRepositoryComponent = DaggerUserRepositoryComponent.create();// 创建目标对象实例UserDataManager userDataManager = new UserDataManager(null, null);// 使用组件实例将依赖对象注入到目标对象中userRepositoryComponent.inject(userDataManager);// 调用目标对象的方法userDataManager.fetchAllUserData();}
}
源码分析
  • 组件 DaggerUserRepositoryComponent

java

public final class DaggerUserRepositoryComponent implements UserRepositoryComponent {private final UserRepositoryModule userRepositoryModule;private DaggerUserRepositoryComponent(UserRepositoryModule userRepositoryModule) {this.userRepositoryModule = userRepositoryModule;}public static UserRepositoryComponent create() {return new DaggerUserRepositoryComponent(new UserRepositoryModule());}@Overridepublic void inject(UserDataManager manager) {// 根据限定符获取对应的依赖对象UserRepository remoteUserRepository = userRepositoryModule.provideRemoteUserRepository();UserRepository localUserRepository = userRepositoryModule.provideLocalUserRepository();// 将依赖对象注入到目标对象中new UserDataManager(remoteUserRepository, localUserRepository);}
}

在组件的注入方法中,根据限定符调用相应的提供依赖对象的方法,确保将正确的依赖对象注入到 UserDataManager 中。

十、辅助工具模块的未来发展趋势

10.1 与 Kotlin 的深度融合

随着 Kotlin 在 Android 开发中占据越来越重要的地位,Dagger2 的辅助工具模块很可能会与 Kotlin 进行更深度的融合。例如,提供更符合 Kotlin 语言习惯的 API,利用 Kotlin 的协程、扩展函数等特性来简化依赖注入的代码。同时,借助 Kotlin 的编译时注解处理能力,进一步优化代码生成的效率和质量。

10.2 对 Android 架构组件的全面支持

随着 Android 架构组件(如 ViewModel、LiveData、Room 等)的不断发展和完善,Dagger2 的辅助工具模块将提供更全面的支持。例如,能够更方便地将 ViewModel 的依赖注入集成到 Dagger2 的体系中,通过多绑定和限定符管理不同类型的 LiveData 数据源,以及与 Room 数据库的 DAO 接口进行无缝集成,实现数据库操作的依赖注入。

10.3 性能和代码生成的持续优化

未来,Dagger2 的辅助工具模块将持续在性能和代码生成方面进行优化。一方面,通过改进注解处理器的算法,减少生成代码的体积和复杂度,提高编译速度;另一方面,利用最新的 Java 或 Kotlin 语言特性,生成更高效、更简洁的依赖注入代码,降低运行时的开销。

10.4 与其他框架的集成增强

Dagger2 可能会与更多的第三方框架进行集成,如 Retrofit、OkHttp、RxJava 等。通过辅助工具模块,开发者可以更轻松地将这些框架的依赖对象集成到 Dagger2 的依赖注入体系中,实现更高效的代码组织和管理。

十一、总结

Dagger2 的辅助工具模块为 Android 开发者提供了丰富而强大的功能,通过多绑定、限定符、依赖替换和子组件等特性,能够显著提高代码的可维护性、可测试性和灵活性。在实际开发中,开发者可以根据具体的需求,合理运用这些辅助工具,优化代码结构,降低代码的耦合度。

同时,在使用辅助工具模块时,需要注意一些问题,如避免不必要的多绑定和限定符使用,防止子组件作用域冲突等。通过掌握调试和错误处理技巧,能够快速定位和解决开发过程中遇到的问题。

随着 Android 开发技术的不断发展,Dagger2 的辅助工具模块也将不断演进和完善,为开发者带来更多的便利和惊喜。深入理解和掌握这些辅助工具模块的原理和使用方法,将有助于开发者编写出更加优秀的 Android 应用程序。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/33915.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Linux:利用System V系列的-共享内存,消息队列实现进程间通信

对于管道的进程间通信方式&#xff0c;需要频繁的调用系统调用(read,write)。而我们今天首先要介绍的共享内存&#xff0c;在开辟好空间之后&#xff0c;便可以跳过系统调用&#xff0c;直接进行读写操作。 一.System V共享内存(主要) 共享内存区是最快的IPC形式。一旦这样的内…

不像人做的题————十四届蓝桥杯省赛真题解析(上)A,B,C,D题解析

题目A&#xff1a;日期统计 思路分析&#xff1a; 本题的题目比较繁琐&#xff0c;我们采用暴力加DFS剪枝的方式去做&#xff0c;我们在DFS中按照8位日期的每一个位的要求进行初步剪枝找出所有的八位子串&#xff0c;但是还是会存在19月的情况&#xff0c;为此还需要在CHECK函数…

宇树人形机器人开源模型

1. 下载源码 https://github.com/unitreerobotics/unitree_ros.git2. 启动Gazebo roslaunch h1_description gazebo.launch3. 仿真效果 H1 GO2 B2 Laikago Z1 4. VMware: vmw_ioctl_command error Invalid argument 这个错误通常出现在虚拟机环境中运行需要OpenGL支持的应用…

【C/C++算法】从浅到深学习--- 前缀和算法(图文兼备 + 源码详解)

绪论&#xff1a;冲击蓝桥杯一起加油&#xff01;&#xff01; 每日激励&#xff1a;“不设限和自我肯定的心态&#xff1a;I can do all things。 — Stephen Curry” 绪论​&#xff1a; 本章将使用八道题由浅到深的带你了解并基本掌握前缀和思想&#xff0c;以及前缀和的基…

脑电:时域分析(任务态)

时域分析&#xff1a;时间序列&#xff08;时域信号&#xff09; EEG和ERP都是时间序列 ERP&#xff1a;事件诱发的电位是随着时间变化 组水平&#xff1a;需要这一组的个体不能差异性太大。 提值的指标&#xff0c;选取平均幅值确定成分的显著情况 mean(EEG.data,3): 在第…

【C语言】自定义类型:结构体,联合,枚举(下)

前言&#xff1b;上一期我们侧重讲了一个非常重要的自定义类型结构体&#xff0c;这一期我们来说说另外两种自定义类型&#xff1a;联合&#xff0c;和枚举。 传送门&#xff1a;自定义类型&#xff1a;结构体&#xff0c;联合&#xff0c;枚举(上) 文章目录 一&#xff0c;联…

数组的介绍

1.数组的概念 数组是一组相同类型元素的集合&#xff0c;从这个描述中我们知道&#xff1a; 数组中存放1个或多个数据&#xff0c;但是数组的元素个数不为0。数组中存放的多个数据&#xff0c;类型是相同的。 数组分为一维数组和多维数组&#xff0c;多维数组一般比较多见的…

蓝桥杯 17110抓娃娃

问题描述 小明拿了 n 条线段练习抓娃娃。他将所有线段铺在数轴上&#xff0c;第 i 条线段的左端点在 li&#xff0c;右端点在 ri​。小明用 m 个区间去框这些线段&#xff0c;第 i个区间的范围是 [Li​, Ri​]。如果一个线段有 至少一半 的长度被包含在某个区间内&#xff0c;…

linux ptrace 图文详解(二) PTRACE_TRACEME 跟踪程序

目录 一、基础介绍 二、PTRACE_TRACE 实现原理 三、代码实现 四、总结 &#xff08;代码&#xff1a;linux 6.3.1&#xff0c;架构&#xff1a;arm64&#xff09; One look is worth a thousand words. —— Tess Flanders 一、基础介绍 GDB&#xff08;GNU Debugger&…

记录致远OA服务器硬盘升级过程

前言 日常使用中OA系统突然卡死&#xff0c;刷新访问进不去系统&#xff0c;ping服务器地址正常&#xff0c;立马登录服务器检查&#xff0c;一看磁盘爆了。 我大脑直接萎缩了&#xff0c;谁家OA系统配400G的空间啊&#xff0c;过我手的服务器没有50也是30台&#xff0c;还是…

电网电压暂态扰动机理与工业设备抗失压防护策略研究

什么是晃电&#xff1f; 国标GB/T 30137-2013 中定义:工频电压方均根值突然降至额定值的90%~10%&#xff0c;持续时间为10ms~1min后恢复正常的现象。Acrel8757V 晃电的原因 1.系统侧因素 短路故障&#xff1a;雷击、线路接地、设备误碰等导致电网短路&#xff0c;故障点电压…

Linux监控网络状态

一、基本介绍 1、基本语法 netstat [选项] 2、常用选项 选项 说明 -a 显示所有连接和监听的套接字&#xff08;包括TCP、UDP&#xff09;。 -t 显示 TCP 连接。 -u 显示 UDP 连接。 -l 显示正在监听的套接字&#xff08;server端&#xff09;。 -n 显示数字格式的…

UE5以插件的形式加载第三方库

之前在UE中加载第三方库的形式是以静态或者动态链接的形式加载但是不太容易复用。就想着能不能以插件的形式加载第三方库&#xff0c;这样直接把插件打包发行就可以复用了&#xff0c;之前也找过相应的教程但是很难找到比较简单易懂的教程&#xff0c;要么是比较复杂&#xff0…

Go执行当前package下的所有方法

需求&#xff1a;需要一个文件一个定时任务方法&#xff0c;当项目初始化完毕后&#xff0c;自动加载并执行这些定时任务方法 项目目录架构 main.go 初始化 package mainimport ("sql_demo/schedule" )func main() {/***** 其他初始化完毕后的操作**/// 定时任务sc…

AnyAnomaly: 基于大型视觉语言模型的零样本可定制视频异常检测

文章目录 速览摘要1. 引言2. 相关工作视频异常检测大型视觉语言模型&#xff08;LVLMs&#xff09; 3. 方法3.1. 总览3.2. 关键帧选择模块3.3. 上下文生成基于 WinCLIP 的注意力机制网格图像生成 3.4. 异常检测提示词设计异常评分 4. 实验4.1. 数据集4.2. 评估标准4.3. 结果4.4…

【AWS入门】2025 AWS亚马逊云科技账户注册指南

【AWS入门】2025 AWS亚马逊云科技账户注册指南 A Guide To Register a New account on AWS By JacksonML 0. AWS亚马逊云科技简介 Amazon Web Service(AWS) 即亚马逊云科技&#xff0c;其在全球Cloud Computing(云计算)市场占有最为重要的地位。 AWS连续13年被Gartner评为…

Spring 中 SmartInitializingSingleton 的作用和示例

一、 接口定义 SmartInitializingSingleton 是 Spring 框架提供的一个 单例 Bean 全局初始化回调接口&#xff0c;用于在 所有非延迟单例 Bean 初始化完成后 执行自定义逻辑。 核心方法&#xff1a; public interface SmartInitializingSingleton {void afterSingletonsInsta…

element tree树形结构默认展开全部

背景&#xff1a; el-tree树形结构&#xff0c;默认展开全部&#xff0c;使用属性default-expand-all【是否默认展开所有节点】&#xff1b;默认展开一级&#xff0c;设置default-expanded-keys【默认展开的节点的 key 的数组】属性值为数组。 因为我这里的数据第一级是四川【省…

大数据-spark3.5安装部署之local模式

spark&#xff0c;一个数据处理框架和计算引擎。 下载 local模式即本地模式&#xff0c;就是不需要任何其他节点资源就可以在本地执行spark代码的环境。用于练习演示。 上传解压 使用PortX将文件上传至/opt 进入/opt目录&#xff0c;创建目录module&#xff0c;解压文件至/o…

Discuz建站教程之论坛头部logo跳转链接怎么修改?

在修改头部logo跳转链接前&#xff0c;我们需要知道对应代码在哪个文件目录&#xff0c;进入宝塔或是服务器&#xff0c;找到文件&#xff1a;\template\default\common\header.htm&#xff0c;编辑器打开&#xff0c;搜索以下代码&#xff0c;大概在135行 <a href"{i…