许多应用使用 Hilt 向不同的 build 变体注入不同的行为。这在对应用进行微基准测试时特别有用，因为您可以更换可能导致结果偏差的组件。例如，以下代码段展示了一个用于提取名称列表并对其进行排序的代码库：
Kotlin
class PeopleRepository @Inject constructor(
@Kotlin private val dataSource: NetworkDataSource,
@Dispatcher(DispatcherEnum.IO) private val dispatcher: CoroutineDispatcher
) {
private val _peopleLiveData = MutableLiveData<List<Person>>()
val peopleLiveData: LiveData<List<Person>>
get() = _peopleLiveData
suspend fun update() {
withContext(dispatcher) {
_peopleLiveData.postValue(
dataSource.getPeople()
.sortedWith(compareBy({ it.lastName }, { it.firstName }))
)
}
}
}}
Java
public class PeopleRepository {
private final MutableLiveData<List<Person>> peopleLiveData = new MutableLiveData<>();
private final NetworkDataSource dataSource;
public LiveData<List<Person>> getPeopleLiveData() {
return peopleLiveData;
}
@Inject
public PeopleRepository(NetworkDataSource dataSource) {
this.dataSource = dataSource;
}
private final Comparator<Person> comparator = Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName);
public void update() {
Runnable task = new Runnable() {
@Override
public void run() {
peopleLiveData.postValue(
dataSource.getPeople()
.stream()
.sorted(comparator)
.collect(Collectors.toList())
);
}
};
new Thread(task).start();
}
}
如果您在进行基准测试时添加了网络调用，请实现虚假网络调用，以获取更准确的结果。
在进行基准测试时加入真实的网络调用会导致更难以解读基准测试结果。网络调用可能会受许多外部因素的影响，并且其时长可能会因运行基准测试的迭代而异。网络调用的时长可能比排序的时间更长。
使用 Hilt 实现虚假网络调用
如上例所示，对 dataSource.getPeople() 的调用包含网络调用。不过，NetworkDataSource 实例由 Hilt 注入，您可以将其替换为以下虚构实现以进行基准测试：
Kotlin
class FakeNetworkDataSource @Inject constructor(
private val people: List<Person>
) : NetworkDataSource {
override fun getPeople(): List<Person> = people
}
Java
public class FakeNetworkDataSource implements NetworkDataSource{
private List<Person> people;
@Inject
public FakeNetworkDataSource(List<Person> people) {
this.people = people;
}
@Override
public List<Person> getPeople() {
return people;
}
}
此虚构网络调用旨在在您调用 getPeople() 方法时以最快的速度运行。为了让 Hilt 能够注入此资源，请使用以下提供程序：
Kotlin
@Module
@InstallIn(SingletonComponent::class)
object FakekNetworkModule {
@Provides
@Kotlin
fun provideNetworkDataSource(@ApplicationContext context: Context): NetworkDataSource {
val data = context.assets.open("fakedata.json").use { inputStream ->
val bytes = ByteArray(inputStream.available())
inputStream.read(bytes)
val gson = Gson()
val type: Type = object : TypeToken<List<Person>>() {}.type
gson.fromJson<List<Person>>(String(bytes), type)
}
return FakeNetworkDataSource(data)
}
}
Java
@Module
@InstallIn(SingletonComponent.class)
public class FakeNetworkModule {
@Provides
@Java
NetworkDataSource provideNetworkDataSource(
@ApplicationContext Context context
) {
List<Person> data = new ArrayList<>();
try (InputStream inputStream = context.getAssets().open("fakedata.json")) {
int size = inputStream.available();
byte[] bytes = new byte[size];
if (inputStream.read(bytes) == size) {
Gson gson = new Gson();
Type type = new TypeToken<ArrayList<Person>>() {
}.getType();
data = gson.fromJson(new String(bytes), type);
}
} catch (IOException e) {
// Do something
}
return new FakeNetworkDataSource(data);
}
}
使用长度可能可变的 I/O 调用从资源中加载数据。不过，这是在初始化期间完成的，在基准测试期间调用 getPeople() 时不会导致任何异常。
某些应用已在调试 build 中使用虚假对象来移除所有后端依赖项。不过，您需要对尽可能接近发布 build 的 build 进行基准测试。本文档的其余部分使用完整项目设置中所述的多模块、多变体结构。
一共有三个模块：
benchmarkable：包含要进行基准测试的代码。benchmark：包含基准代码。app：包含其余的应用代码。
上述每个模块都有一个名为 benchmark 的 build 变体，以及常用的 debug 和 release 变体。
配置基准模块
虚构网络调用的代码位于 benchmarkable 模块的 debug 源代码集中，完整的网络实现则位于同一模块的 release 源代码集中。包含虚构实现所返回数据的资源文件位于 debug 源代码集中，以避免 release build 中出现任何 APK 膨胀。benchmark 变体需要基于 release 并使用 debug 源代码集。包含虚构实现的 benchmarkable 模块的 benchmark 变体的 build 配置如下所示：
Kotlin
android {
...
buildTypes {
release {
isMinifyEnabled = false
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
}
create("benchmark") {
initWith(getByName("release"))
}
}
...
sourceSets {
getByName("benchmark") {
java.setSrcDirs(listOf("src/debug/java"))
assets.setSrcDirs(listOf("src/debug/assets"))
}
}
}
Groovy
android {
...
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
'proguard-rules.pro'
)
}
benchmark {
initWith release
}
}
...
sourceSets {
benchmark {
java.setSrcDirs ['src/debug/java']
assets.setSrcDirs(listOf ['src/debug/assets']
}
}
}
在 benchmark 模块中，添加一个自定义测试运行程序，用于创建 Application 来运行支持 Hilt 的测试，如下所示：
Kotlin
class HiltBenchmarkRunner : AndroidBenchmarkRunner() {
override fun newApplication(
cl: ClassLoader?,
className: String?,
context: Context?
): Application {
return super.newApplication(cl, HiltTestApplication::class.java.name, context)
}
}
Java
public class JavaHiltBenchmarkRunner extends AndroidBenchmarkRunner {
@Override
public Application newApplication(
ClassLoader cl,
String className,
Context context
) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return super.newApplication(cl, HiltTestApplication.class.getName(), context);
}
}
这会使得运行测试的 Application 对象扩展了 HiltTestApplication 类。对 build 配置进行以下更改：
Kotlin
plugins {
alias(libs.plugins.android.library)
alias(libs.plugins.benchmark)
alias(libs.plugins.jetbrains.kotlin.android)
alias(libs.plugins.kapt)
alias(libs.plugins.hilt)
}
android {
namespace = "com.example.hiltmicrobenchmark.benchmark"
compileSdk = 34
defaultConfig {
minSdk = 24
testInstrumentationRunner = "com.example.hiltbenchmark.HiltBenchmarkRunner"
}
testBuildType = "benchmark"
buildTypes {
debug {
// Since isDebuggable can't be modified by Gradle for library modules,
// it must be done in a manifest. See src/androidTest/AndroidManifest.xml.
isMinifyEnabled = true
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"benchmark-proguard-rules.pro"
)
}
create("benchmark") {
initWith(getByName("debug"))
}
}
}
dependencies {
androidTestImplementation(libs.bundles.hilt)
androidTestImplementation(project(":benchmarkable"))
implementation(libs.androidx.runner)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.junit)
implementation(libs.androidx.benchmark)
implementation(libs.google.dagger.hiltTesting)
kaptAndroidTest(libs.google.dagger.hiltCompiler)
androidTestAnnotationProcessor(libs.google.dagger.hiltCompiler)
}
Groovy
plugins {
alias libs.plugins.android.library
alias libs.plugins.benchmark
alias libs.plugins.jetbrains.kotlin.android
alias libs.plugins.kapt
alias libs.plugins.hilt
}
android {
namespace = 'com.example.hiltmicrobenchmark.benchmark'
compileSdk = 34
defaultConfig {
minSdk = 24
testInstrumentationRunner 'com.example.hiltbenchmark.HiltBenchmarkRunner'
}
testBuildType "benchmark"
buildTypes {
debug {
// Since isDebuggable can't be modified by Gradle for library modules,
// it must be done in a manifest. See src/androidTest/AndroidManifest.xml.
minifyEnabled true
proguardFiles(
getDefaultProguardFile('proguard-android-optimize.txt'),
'benchmark-proguard-rules.pro'
)
}
benchmark {
initWith debug"
}
}
}
dependencies {
androidTestImplementation libs.bundles.hilt
androidTestImplementation project(':benchmarkable')
implementation libs.androidx.runner
androidTestImplementation libs.androidx.junit
androidTestImplementation libs.junit
implementation libs.androidx.benchmark
implementation libs.google.dagger.hiltTesting
kaptAndroidTest libs.google.dagger.hiltCompiler
androidTestAnnotationProcessor libs.google.dagger.hiltCompiler
}
上述示例会执行以下操作：
- 将必要的 Gradle 插件应用于 build。
- 指定使用自定义测试运行程序来运行测试。
- 指定
benchmark变体是此模块的测试类型。 - 添加
benchmark变体。 - 添加所需的依赖项。
您需要更改 testBuildType 以确保 Gradle 创建执行基准测试的 connectedBenchmarkAndroidTest 任务。
创建 Microbenchmark
基准的实现方式如下：
Kotlin
@RunWith(AndroidJUnit4::class)
@HiltAndroidTest
class PeopleRepositoryBenchmark {
@get:Rule
val benchmarkRule = BenchmarkRule()
@get:Rule
val hiltRule = HiltAndroidRule(this)
private val latch = CountdownLatch(1)
@Inject
lateinit var peopleRepository: PeopleRepository
@Before
fun setup() {
hiltRule.inject()
}
@Test
fun benchmarkSort() {
benchmarkRule.measureRepeated {
runBlocking {
benchmarkRule.getStart().pauseTiming()
withContext(Dispatchers.Main.immediate) {
peopleRepository.peopleLiveData.observeForever(observer)
}
benchmarkRule.getStart().resumeTiming()
peopleRepository.update()
latch.await()
assert(peopleRepository.peopleLiveData.value?.isNotEmpty() ?: false)
}
}
}
private val observer: Observer<List<Person>> = object : Observer<List<Person>> {
override fun onChanged(people: List<Person>?) {
peopleRepository.peopleLiveData.removeObserver(this)
latch.countDown()
}
}
}
Java
@RunWith(AndroidJUnit4.class)
@HiltAndroidTest
public class PeopleRepositoryBenchmark {
@Rule
public BenchmarkRule benchmarkRule = new BenchmarkRule();
@Rule
public HiltAndroidRule hiltRule = new HiltAndroidRule(this);
private CountdownLatch latch = new CountdownLatch(1);
@Inject
JavaPeopleRepository peopleRepository;
@Before
public void setup() {
hiltRule.inject();
}
@Test
public void benchmarkSort() {
BenchmarkRuleKt.measureRepeated(benchmarkRule, (Function1<BenchmarkRule.Scope, Unit>) scope -> {
benchmarkRule.getState().pauseTiming();
new Handler(Looper.getMainLooper()).post(() -> {
awaitValue(peopleRepository.getPeopleLiveData());
});
benchmarkRule.getState().resumeTiming();
peopleRepository.update();
try {
latch.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
assert (!peopleRepository.getPeopleLiveData().getValue().isEmpty());
return Unit.INSTANCE;
});
}
private <T> void awaitValue(LiveData<T> liveData) {
Observer<T> observer = new Observer<T>() {
@Override
public void onChanged(T t) {
liveData.removeObserver(this);
latch.countDown();
}
};
liveData.observeForever(observer);
return;
}
}
上面的示例为基准和 Hilt 创建了规则。benchmarkRule 会执行基准的时间设置。hiltRule 会对基准测试类执行依赖项注入。在运行任何单个测试之前，您必须在 @Before 函数中调用 Hilt 规则的 inject() 方法来执行注入。
在注册 LiveData 观察器时，基准测试本身会暂停计时。然后，它使用锁存器等到 LiveData 更新后再完成。由于排序是从调用 peopleRepository.update() 到 LiveData 收到更新这段时间运行的，因此排序的时长会计入基准测试时间。
运行 Microbenchmark
使用 ./gradlew :benchmark:connectedBenchmarkAndroidTest 运行基准测试，以多次迭代执行基准测试，并将时间数据输出到 Logcat：
PeopleRepositoryBenchmark.log[Metric (timeNs) results: median 613408.3952380952, min 451949.30476190476, max 1412143.5142857144, standardDeviation: 273221.2328680522...
上面的示例显示了在 0.6 毫秒到 1.4 毫秒之间对包含 1,000 个项的列表运行排序算法的基准测试结果。但是，如果您将网络调用包含在基准中，则迭代之间的方差大于排序本身的运行时间，因此需要将排序与网络调用隔离开来。
您可以随时重构代码，以便更轻松地单独运行排序；但如果您已经在使用 Hilt，则可以改用它来注入虚假数据以进行基准测试。