许多应用都使用 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 模块中，添加一个自定义测试运行程序，用于创建一个支持 Hilt 的 Application 以供测试运行，如下所示：
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 任务。
创建微基准
基准测试的实现方式如下：
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...
上例显示了在 1,000 个项的列表上运行排序算法的基准测试结果，介于 0.6 毫秒到 1.4 毫秒之间。但是，如果您在基准测试中添加网络调用，则迭代之间的方差会大于排序本身运行的时间，因此需要将排序与网络调用分离。
您可以随时重构代码，以便更轻松地单独运行排序，但如果您已经在使用 Hilt，则可以改用它来注入虚构对象以进行基准测试。